//------------------------------------------------------------------------------
// <copyright file="MainWindow.xaml.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace Microsoft.Samples.Kinect.BodyBasics
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq;
    using System.Diagnostics;
    using System.Globalization;
    using System.IO;
    using System.Windows;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Threading;
    using Microsoft.Kinect;
    using IronPython.Hosting;
    using Microsoft.Scripting.Hosting;

    /// <summary>
    /// Interaction logic for MainWindow
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {

        enum STATE
        {
            APP_START, FIRST_STATE_READY, FIRST_STATE_START, FIRST_STATE_CAL, FIRST_STATE_CANCEL, FIRST_STATE_END,
            SECOND_STATE_START, SECOND_STATE_CAL, SECOND_STATE_CANCEL, SECOND_STATE_END
        }

        int nowState = (int)STATE.APP_START;

        /// <summary>
        /// Radius of drawn hand circles
        /// </summary>
        private const double HandSize = 30;

        /// <summary>
        /// Thickness of drawn joint lines
        /// </summary>
        private const double JointThickness = 3;

        /// <summary>
        /// Thickness of clip edge rectangles
        /// </summary>
        private const double ClipBoundsThickness = 10;

        /// <summary>
        /// Constant for clamping Z values of camera space points from being negative
        /// </summary>
        private const float InferredZPositionClamp = 0.1f;

        /// <summary>
        /// Brush used for drawing hands that are currently tracked as closed
        /// </summary>
        private readonly Brush handClosedBrush = new SolidColorBrush(Color.FromArgb(128, 255, 0, 0));

        /// <summary>
        /// Brush used for drawing hands that are currently tracked as opened
        /// </summary>
        private readonly Brush handOpenBrush = new SolidColorBrush(Color.FromArgb(128, 0, 255, 0));

        /// <summary>
        /// Brush used for drawing hands that are currently tracked as in lasso (pointer) position
        /// </summary>
        private readonly Brush handLassoBrush = new SolidColorBrush(Color.FromArgb(128, 0, 0, 255));

        /// <summary>
        /// Brush used for drawing joints that are currently tracked
        /// </summary>
        private readonly Brush trackedJointBrush = new SolidColorBrush(Color.FromArgb(255, 68, 192, 68));

        /// <summary>
        /// Brush used for drawing joints that are currently inferred
        /// </summary>        
        private readonly Brush inferredJointBrush = Brushes.Yellow;

        /// <summary>
        /// Pen used for drawing bones that are currently inferred
        /// </summary>        
        private readonly Pen inferredBonePen = new Pen(Brushes.Gray, 1);

        /// <summary>
        /// Drawing group for body rendering output
        /// </summary>
        private DrawingGroup drawingGroup;

        /// <summary>
        /// Drawing image that we will display
        /// </summary>
        private DrawingImage imageSource;

        /// <summary>
        /// Active Kinect sensor
        /// </summary>
        private KinectSensor kinectSensor = null;

        /// <summary>
        /// Coordinate mapper to map one type of point to another
        /// </summary>
        private CoordinateMapper coordinateMapper = null;

        /// <summary>
        /// Reader for body frames
        /// </summary>
        private BodyFrameReader bodyFrameReader = null;

        /// <summary>
        /// Reader for multi frames
        /// </summary>
        private MultiSourceFrameReader multiSourceFrameReader = null;

        /// <summary>
        /// Array for the bodies
        /// </summary>
        private Body[] bodies = null;

        /// <summary>
        /// definition of bones
        /// </summary>
        private List<Tuple<JointType, JointType>> bones;

        /// <summary>
        /// Width of display (depth space)
        /// </summary>
        private int displayWidth;

        /// <summary>
        /// Height of display (depth space)
        /// </summary>
        private int displayHeight;

        /// <summary>
        /// List of colors for each body tracked
        /// </summary>
        private List<Pen> bodyColors;

        /// <summary>
        /// Current status text to display
        /// </summary>
        private string statusText = null;

        private DispatcherTimer dispatcherTimer = new DispatcherTimer();
        private DispatcherTimer startTimer = new DispatcherTimer();

        private int timeLeft;

        private int countTime;


        private String fdatapath;
        private String sdatapath;

        private StreamWriter Firstdata;
        private StreamWriter Seconddata;

        /// <summary>
        /// Initializes a new instance of the MainWindow class.
        /// </summary>
        public MainWindow()
        {
            // one sensor is currently supported
            this.kinectSensor = KinectSensor.GetDefault();

            // get the coordinate mapper
            this.coordinateMapper = this.kinectSensor.CoordinateMapper;

            // get the depth (display) extents
            FrameDescription frameDescription = this.kinectSensor.DepthFrameSource.FrameDescription;

            // get size of joint space
            this.displayWidth = frameDescription.Width;
            this.displayHeight = frameDescription.Height;

            // open the reader for the body frames
            this.bodyFrameReader = this.kinectSensor.BodyFrameSource.OpenReader();

            // open the reader for the body frames
            this.multiSourceFrameReader = this.kinectSensor.OpenMultiSourceFrameReader(FrameSourceTypes.Color | FrameSourceTypes.Body);

            // a bone defined as a line between two joints
            this.bones = new List<Tuple<JointType, JointType>>();

            // Torso
            this.bones.Add(new Tuple<JointType, JointType>(JointType.Head, JointType.Neck));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.Neck, JointType.SpineShoulder));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineShoulder, JointType.SpineMid));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineMid, JointType.SpineBase));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineShoulder, JointType.ShoulderRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineShoulder, JointType.ShoulderLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineBase, JointType.HipRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.SpineBase, JointType.HipLeft));

            // Right Arm
            this.bones.Add(new Tuple<JointType, JointType>(JointType.ShoulderRight, JointType.ElbowRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.ElbowRight, JointType.WristRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.WristRight, JointType.HandRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.HandRight, JointType.HandTipRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.WristRight, JointType.ThumbRight));

            // Left Arm
            this.bones.Add(new Tuple<JointType, JointType>(JointType.ShoulderLeft, JointType.ElbowLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.ElbowLeft, JointType.WristLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.WristLeft, JointType.HandLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.HandLeft, JointType.HandTipLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.WristLeft, JointType.ThumbLeft));

            // Right Leg
            this.bones.Add(new Tuple<JointType, JointType>(JointType.HipRight, JointType.KneeRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.KneeRight, JointType.AnkleRight));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.AnkleRight, JointType.FootRight));

            // Left Leg
            this.bones.Add(new Tuple<JointType, JointType>(JointType.HipLeft, JointType.KneeLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.KneeLeft, JointType.AnkleLeft));
            this.bones.Add(new Tuple<JointType, JointType>(JointType.AnkleLeft, JointType.FootLeft));

            // populate body colors, one for each BodyIndex
            this.bodyColors = new List<Pen>();

            this.bodyColors.Add(new Pen(Brushes.Red, 6));
            this.bodyColors.Add(new Pen(Brushes.Orange, 6));
            this.bodyColors.Add(new Pen(Brushes.Green, 6));
            this.bodyColors.Add(new Pen(Brushes.Blue, 6));
            this.bodyColors.Add(new Pen(Brushes.Indigo, 6));
            this.bodyColors.Add(new Pen(Brushes.Violet, 6));

            // set IsAvailableChanged event notifier
            this.kinectSensor.IsAvailableChanged += this.Sensor_IsAvailableChanged;

            // open the sensor
            this.kinectSensor.Open();

            // set the status text
            this.StatusText = this.kinectSensor.IsAvailable ? Properties.Resources.RunningStatusText
                                                            : Properties.Resources.NoSensorStatusText;

            // Create the drawing group we'll use for drawing
            this.drawingGroup = new DrawingGroup();

            // Create an image source that we can use in our image control
            this.imageSource = new DrawingImage(this.drawingGroup);

            // use the window object as the view model in this simple example
            this.DataContext = this;

            dispatcherTimer.Interval = TimeSpan.FromSeconds(1);
            dispatcherTimer.Tick += new EventHandler(timer_Tick);

            startTimer.Interval = TimeSpan.FromSeconds(1);
            startTimer.Tick += new EventHandler(starter_Tick);

            fdatapath = "data/first" + System.DateTime.Now.ToString("yyyyMMddhhmmss") + ".csv";
            Firstdata = new StreamWriter(fdatapath, false, System.Text.Encoding.UTF8);

            sdatapath = "data/second" + System.DateTime.Now.ToString("yyyyMMddhhmmss") + ".csv";
            Seconddata = new StreamWriter(sdatapath, false, System.Text.Encoding.UTF8);

            // initialize the components (controls) of the window
            this.InitializeComponent();
        }

        /// <summary>
        /// INotifyPropertyChangedPropertyChanged event to allow window controls to bind to changeable data
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Gets the bitmap to display
        /// </summary>
        public ImageSource ImageSource
        {
            get
            {
                return this.imageSource;
            }
        }

        /// <summary>
        /// Gets or sets the current status text to display
        /// </summary>
        public string StatusText
        {
            get
            {
                return this.statusText;
            }

            set
            {
                if (this.statusText != value)
                {
                    this.statusText = value;

                    // notify any bound elements that the text has changed
                    if (this.PropertyChanged != null)
                    {
                        this.PropertyChanged(this, new PropertyChangedEventArgs("StatusText"));
                    }
                }
            }
        }

        /// <summary>
        /// Execute start up tasks
        /// </summary>
        /// <param name="sender">object sending the event</param>
        /// <param name="e">event arguments</param>
        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            if (this.multiSourceFrameReader != null)
            {
                this.multiSourceFrameReader.MultiSourceFrameArrived += this.Multi_Reader_FrameArrived;
            }
        }

        /// <summary>
        /// Execute shutdown tasks
        /// </summary>
        /// <param name="sender">object sending the event</param>
        /// <param name="e">event arguments</param>
        private void MainWindow_Closing(object sender, CancelEventArgs e)
        {
            if (this.bodyFrameReader != null)
            {
                // BodyFrameReader is IDisposable
                this.bodyFrameReader.Dispose();
                this.bodyFrameReader = null;
            }

            if (this.kinectSensor != null)
            {
                this.kinectSensor.Close();
                this.kinectSensor = null;
            }
        }


        /// <summary>
        /// Handles the body frame data arriving from the sensor
        /// </summary>
        /// <param name="sender">object sending the event</param>
        /// <param name="e">event arguments</param>
        private void Multi_Reader_FrameArrived(object sender, MultiSourceFrameArrivedEventArgs e)
        {
            bool dataReceived = false;
            var reference = e.FrameReference.AcquireFrame();



            using (var bodyFrame = reference.BodyFrameReference.AcquireFrame())
            {
                if (bodyFrame != null)
                {
                    if (this.bodies == null)
                    {
                        this.bodies = new Body[bodyFrame.BodyCount];
                    }

                    // The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
                    // As long as those body objects are not disposed and not set to null in the array,
                    // those body objects will be re-used.
                    bodyFrame.GetAndRefreshBodyData(this.bodies);
                    dataReceived = true;
                }
            }

            if (dataReceived)
            {
                using (DrawingContext dc = this.drawingGroup.Open())
                {
                    // Draw a transparent background to set the render size
                    //dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, this.displayWidth, this.displayHeight));
                    using (var colorFrame = reference.ColorFrameReference.AcquireFrame())
                    {
                        if (colorFrame != null)
                        {
                            dc.DrawImage(ToBitmap(colorFrame), new Rect(0.0, 0.0, this.displayWidth, this.displayHeight));
                        }
                    }

                    int penIndex = 0;
                    foreach (Body body in this.bodies)
                    {
                        Pen drawPen = this.bodyColors[penIndex++];

                        if (body.IsTracked)
                        {
                            this.DrawClippedEdges(body, dc);

                            IReadOnlyDictionary<JointType, Joint> joints = body.Joints;

                            // convert the joint points to depth (display) space
                            Dictionary<JointType, Point> jointPoints = new Dictionary<JointType, Point>();

                            foreach (JointType jointType in joints.Keys)
                            {
                                // sometimes the depth(Z) of an inferred joint may show as negative
                                // clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity)
                                CameraSpacePoint position = joints[jointType].Position;
                                if (position.Z < 0)
                                {
                                    position.Z = InferredZPositionClamp;
                                }

                                DepthSpacePoint depthSpacePoint = this.coordinateMapper.MapCameraPointToDepthSpace(position);
                                jointPoints[jointType] = new Point(depthSpacePoint.X, depthSpacePoint.Y);
                            }



                            this.DrawBody(joints, jointPoints, dc, drawPen);

                            this.DrawHand(body.HandLeftState, jointPoints[JointType.HandLeft], jointPoints[JointType.Head], dc);
                            this.DrawHand(body.HandRightState, jointPoints[JointType.HandRight], jointPoints[JointType.Head], dc);



                            //if(makeDataset && ((jointPoints[JointType.ElbowLeft].Y < jointPoints[JointType.Head].Y) || (jointPoints[JointType.ElbowRight].Y < jointPoints[JointType.Head].Y)))
                            //{
                            //    makeDataset = false;
                            //}

                            if (nowState == (int)STATE.FIRST_STATE_CAL)
                            {
                                Firstdata.WriteLine((jointPoints[JointType.Head].X) + "," + (jointPoints[JointType.Head].Y)
                                + "," + (jointPoints[JointType.Neck].X) + "," + (jointPoints[JointType.Neck].Y)
                                + "," + (jointPoints[JointType.SpineShoulder].X) + "," + (jointPoints[JointType.SpineShoulder].Y)
                                + "," + (jointPoints[JointType.ShoulderRight].X) + "," + (jointPoints[JointType.ShoulderRight].Y)
                                + "," + (jointPoints[JointType.ShoulderLeft].X) + "," + (jointPoints[JointType.ShoulderLeft].Y)
                                + "," + (jointPoints[JointType.ElbowRight].X) + "," + (jointPoints[JointType.ElbowRight].Y)
                                + "," + (jointPoints[JointType.ElbowLeft].X) + "," + (jointPoints[JointType.ElbowLeft].Y)
                                + "," + (jointPoints[JointType.WristRight].X) + "," + (jointPoints[JointType.WristRight].Y)
                                + "," + (jointPoints[JointType.WristLeft].X) + "," + (jointPoints[JointType.WristLeft].Y));
                            }

                            if (nowState == (int)STATE.SECOND_STATE_CAL)
                            {
                                Seconddata.WriteLine((jointPoints[JointType.Head].X) + "," + (jointPoints[JointType.Head].Y)
                                + "," + (jointPoints[JointType.Neck].X) + "," + (jointPoints[JointType.Neck].Y)
                                + "," + (jointPoints[JointType.SpineShoulder].X) + "," + (jointPoints[JointType.SpineShoulder].Y)
                                + "," + (jointPoints[JointType.ShoulderRight].X) + "," + (jointPoints[JointType.ShoulderRight].Y)
                                + "," + (jointPoints[JointType.ShoulderLeft].X) + "," + (jointPoints[JointType.ShoulderLeft].Y)
                                + "," + (jointPoints[JointType.ElbowRight].X) + "," + (jointPoints[JointType.ElbowRight].Y)
                                + "," + (jointPoints[JointType.ElbowLeft].X) + "," + (jointPoints[JointType.ElbowLeft].Y)
                                + "," + (jointPoints[JointType.WristRight].X) + "," + (jointPoints[JointType.WristRight].Y)
                                + "," + (jointPoints[JointType.WristLeft].X) + "," + (jointPoints[JointType.WristLeft].Y));
                            }
                        }
                    }

                    // prevent drawing outside of our render area
                    this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.displayWidth, this.displayHeight));
                }
            }
        }

        /// <summary>
        /// Draws a body
        /// </summary>
        /// <param name="joints">joints to draw</param>
        /// <param name="jointPoints">translated positions of joints to draw</param>
        /// <param name="drawingContext">drawing context to draw to</param>
        /// <param name="drawingPen">specifies color to draw a specific body</param>
        private void DrawBody(IReadOnlyDictionary<JointType, Joint> joints, IDictionary<JointType, Point> jointPoints, DrawingContext drawingContext, Pen drawingPen)
        {
            // Draw the bones
            foreach (var bone in this.bones)
            {
                this.DrawBone(joints, jointPoints, bone.Item1, bone.Item2, drawingContext, drawingPen);
            }

            // Draw the joints
            foreach (JointType jointType in joints.Keys)
            {
                Brush drawBrush = null;

                TrackingState trackingState = joints[jointType].TrackingState;

                if (trackingState == TrackingState.Tracked)
                {
                    drawBrush = this.trackedJointBrush;
                }
                else if (trackingState == TrackingState.Inferred)
                {
                    drawBrush = this.inferredJointBrush;
                }

                if (drawBrush != null)
                {
                    drawingContext.DrawEllipse(drawBrush, null, jointPoints[jointType], JointThickness, JointThickness);
                }
            }
        }

        /// <summary>
        /// Draws one bone of a body (joint to joint)
        /// </summary>
        /// <param name="joints">joints to draw</param>
        /// <param name="jointPoints">translated positions of joints to draw</param>
        /// <param name="jointType0">first joint of bone to draw</param>
        /// <param name="jointType1">second joint of bone to draw</param>
        /// <param name="drawingContext">drawing context to draw to</param>
        /// /// <param name="drawingPen">specifies color to draw a specific bone</param>
        private void DrawBone(IReadOnlyDictionary<JointType, Joint> joints, IDictionary<JointType, Point> jointPoints, JointType jointType0, JointType jointType1, DrawingContext drawingContext, Pen drawingPen)
        {
            Joint joint0 = joints[jointType0];
            Joint joint1 = joints[jointType1];

            // If we can't find either of these joints, exit
            if (joint0.TrackingState == TrackingState.NotTracked ||
                joint1.TrackingState == TrackingState.NotTracked)
            {
                return;
            }

            // We assume all drawn bones are inferred unless BOTH joints are tracked
            Pen drawPen = this.inferredBonePen;
            if ((joint0.TrackingState == TrackingState.Tracked) && (joint1.TrackingState == TrackingState.Tracked))
            {
                drawPen = drawingPen;
            }

            drawingContext.DrawLine(drawPen, jointPoints[jointType0], jointPoints[jointType1]);
        }

        /// <summary>
        /// Draws a hand symbol if the hand is tracked: red circle = closed, green circle = opened; blue circle = lasso
        /// </summary>
        /// <param name="handState">state of the hand</param>
        /// <param name="handPosition">position of the hand</param>
        /// <param name="drawingContext">drawing context to draw to</param>
        private void DrawHand(HandState handState, Point handPosition, Point headPosition,DrawingContext drawingContext)
        {
            switch (handState)
            {
                case HandState.Closed:
                    drawingContext.DrawEllipse(this.handClosedBrush, null, handPosition, HandSize, HandSize);
                    if (nowState == (int)STATE.FIRST_STATE_END && handPosition.Y > headPosition.Y)
                    {
                        timeLeft = 4;
                        timer.Content = "3초";
                        state.Content = "Please stretch your hands forward!";
                        dispatcherTimer.Start();
                        nowState = (int)STATE.SECOND_STATE_START;
                    }
                    break;

                case HandState.Open:
                    if (nowState == (int)STATE.APP_START && handPosition.Y > headPosition.Y)
                    {
                        timeLeft = 4;
                        timer.Content = "3초";
                        state.Content = "Please raise your hands!";
                        dispatcherTimer.Start();
                        nowState = (int)STATE.FIRST_STATE_READY;
                    }
                    drawingContext.DrawEllipse(this.handOpenBrush, null, handPosition, HandSize, HandSize);
                    break;

                case HandState.Lasso:
                    drawingContext.DrawEllipse(this.handLassoBrush, null, handPosition, HandSize, HandSize);
                    break;
            }

        }

        /// <summary>
        /// Draws indicators to show which edges are clipping body data
        /// </summary>
        /// <param name="body">body to draw clipping information for</param>
        /// <param name="drawingContext">drawing context to draw to</param>
        private void DrawClippedEdges(Body body, DrawingContext drawingContext)
        {
            FrameEdges clippedEdges = body.ClippedEdges;

            if (clippedEdges.HasFlag(FrameEdges.Bottom))
            {
                drawingContext.DrawRectangle(
                    Brushes.Red,
                    null,
                    new Rect(0, this.displayHeight - ClipBoundsThickness, this.displayWidth, ClipBoundsThickness));
            }

            if (clippedEdges.HasFlag(FrameEdges.Top))
            {
                drawingContext.DrawRectangle(
                    Brushes.Red,
                    null,
                    new Rect(0, 0, this.displayWidth, ClipBoundsThickness));
            }

            if (clippedEdges.HasFlag(FrameEdges.Left))
            {
                drawingContext.DrawRectangle(
                    Brushes.Red,
                    null,
                    new Rect(0, 0, ClipBoundsThickness, this.displayHeight));
            }

            if (clippedEdges.HasFlag(FrameEdges.Right))
            {
                drawingContext.DrawRectangle(
                    Brushes.Red,
                    null,
                    new Rect(this.displayWidth - ClipBoundsThickness, 0, ClipBoundsThickness, this.displayHeight));
            }
        }

        /// <summary>
        /// Handles the event which the sensor becomes unavailable (E.g. paused, closed, unplugged).
        /// </summary>
        /// <param name="sender">object sending the event</param>
        /// <param name="e">event arguments</param>
        private void Sensor_IsAvailableChanged(object sender, IsAvailableChangedEventArgs e)
        {
            // on failure, set the status text
            this.StatusText = this.kinectSensor.IsAvailable ? Properties.Resources.RunningStatusText
                                                            : Properties.Resources.SensorNotAvailableStatusText;
        }
        private ImageSource ToBitmap(ColorFrame frame)
        {
            int width = frame.FrameDescription.Width;
            int height = frame.FrameDescription.Height;
            PixelFormat format = PixelFormats.Bgr32;

            byte[] pixels = new byte[width * height * ((format.BitsPerPixel + 7) / 8)];

            if (frame.RawColorImageFormat == ColorImageFormat.Bgra)
            {
                frame.CopyRawFrameDataToArray(pixels);
            }
            else
            {
                frame.CopyConvertedFrameDataToArray(pixels, ColorImageFormat.Bgra);
            }

            int stride = width * format.BitsPerPixel / 8;

            return BitmapSource.Create(width, height, 96, 96, format, null, pixels, stride);
        }

        private void timer_Tick(object sender, EventArgs e)
        {
            if(nowState == (int)STATE.FIRST_STATE_READY)
            {
                if (timeLeft > 1)
                {
                    timeLeft--;
                    timer.Content = timeLeft - 1 + "초";
                }
                else if (timeLeft == 1)
                {
                    timeLeft--;
                    timer.Content = "Start!";
                }
                else
                {
                    dispatcherTimer.Stop();
                    timer.Content = "Start!";
                    nowState = (int)STATE.FIRST_STATE_CAL;
                    countTime = 10;
                    timer.Content = "10초";
                    state.Content = "Please stay...";
                    startTimer.Start();

                }
            }

            if (nowState == (int)STATE.SECOND_STATE_START)
            {
                if (timeLeft > 1)
                {
                    timeLeft--;
                    timer.Content = timeLeft - 1 + "초";
                }
                else if (timeLeft == 1)
                {
                    timeLeft--;
                    timer.Content = "Start!";
                }
                else
                {
                    dispatcherTimer.Stop();
                    timer.Content = "Start!";
                    nowState = (int)STATE.SECOND_STATE_CAL;
                    countTime = 10;
                    timer.Content = "10초";
                    state.Content = "Please stay...";
                    startTimer.Start();
                }
            }
        }

        private void starter_Tick(object sender, EventArgs e)
        {
            if(nowState == (int)STATE.FIRST_STATE_CAL)
            {
                if (countTime > 0)
                {
                    countTime--;
                    timer.Content = countTime + "초";
                }
                else
                {
                    startTimer.Stop();
                    nowState = (int)STATE.FIRST_STATE_END;
                    timer.Content = "Timer";
                    state.Content = "Please Grab your hands";
                    Firstdata.Close();

                    string[] lines = File.ReadAllLines(fdatapath);
                    Interpolation(lines);
                }
            }

            if (nowState == (int)STATE.SECOND_STATE_CAL)
            {
                if (countTime > 0)
                {
                    countTime--;
                    timer.Content = countTime + "초";
                }
                else
                {
                    startTimer.Stop();
                    nowState = (int)STATE.SECOND_STATE_END;
                    timer.Content = "Timer";
                    state.Content = "END";
                    Firstdata.Close();

                }
            }
        }
        static void Interpolation(IEnumerable<string> strs)
        {
            IEnumerable<IEnumerable<double>> multiColQuery =
                from line in strs
                let elements = line.Split(',')
                let scores = elements
                select (from str in scores
                        select Convert.ToDouble(str));


            var results = multiColQuery.ToList();

            // Find out how many columns you have in results.  
            int columnCount = results[0].Count();

            // Perform aggregate calculations Average, Max, and  
            // Min on each column.              
            // Perform one iteration of the loop for each column   
            // of scores.  
            // You can use a for loop instead of a foreach loop   
            // because you already executed the multiColQuery   
            // query by calling ToList.  

            int len = results.Count();

            double[,] result3 = new double[len, 18];

            Console.WriteLine(results.Count());

            for (int column = 0; column < columnCount; column++)
            {
                var results2 = from row in results
                               select row.ElementAt(column);



                for (int r = 0; r < results2.Count(); r++)
                {
                    result3[r, column] = results2.ElementAt(r);
                    Console.WriteLine(result3[r, column]);


                }

            }



            int length = 401;
            double size = 0;
            double denominator = length - 1;

            double[,] result4 = new double[length, 18];

            StreamWriter dataset = new StreamWriter("output.csv", false, System.Text.Encoding.UTF8);

            for (int i = 0; i < length - 1; i++)
            {
                double temp = Math.Truncate(size / denominator);
                int share = Convert.ToInt32(temp);
                double remain = size % denominator;
                for (int j = 0; j < 18; j++)
                {
                    result4[i, j] = Math.Round(result3[share, j] * (denominator - remain) / denominator + result3[share + 1, j] * remain / denominator, 4);
                    Console.WriteLine(result4[i, j]);
                }
                dataset.WriteLine(result4[i, 0] + "," + result4[i, 1] + "," + result4[i,2] + "," + result4[i, 3] + "," + result4[i, 4]
                    + "," + result4[i, 5] + "," + result4[i, 6] + "," + result4[i, 7] + "," + result4[i, 8] + "," + result4[i, 9]
                    + "," + result4[i, 10] + "," + result4[i, 11] + "," + result4[i, 12] + "," + result4[i, 13] + "," + result4[i, 14]
                    + "," + result4[i, 15] + "," + result4[i, 16] + "," + result4[i, 17]);
                size += len - 1;
            }
            dataset.Close();
        }
    }
}