protected override bool InitTexture(out Texture2D refText, out int xSize, out int ySize)
    {
        if(base.InitTexture(out refText, out xSize, out ySize)==false)
            return false;
        // make sure we have an image to work with
        if (m_context.CurrentContext.Depth == null)
        {
            m_context.m_Logger.Log("No depth", NIEventLogger.Categories.Initialization, NIEventLogger.Sources.BaseObjects, NIEventLogger.VerboseLevel.Errors);
            return false;
        }

        // make sure we have an image to work with
        if(m_factor<=0)
        {
            m_context.m_Logger.Log("Illegal factor", NIEventLogger.Categories.Initialization, NIEventLogger.Sources.Image, NIEventLogger.VerboseLevel.Errors);
            return false;
        }
        // get the resolution from the image
        MapOutputMode mom = m_context.CurrentContext.Depth.MapOutputMode;
        // update the resolution by the factor
        ySize = mom.YRes / m_factor;
        xSize = mom.XRes / m_factor;
        // create the texture
        refText = new Texture2D(xSize, ySize);
        
        // depthmap data
		rawDepthMap = new short[(int)(mom.XRes * mom.YRes)];
		// histogram stuff
		int maxDepth = m_context.CurrentContext.Depth.DeviceMaxDepth;
		depthHistogramMap = new float[maxDepth];
        NIOpenNICheckVersion.Instance.ValidatePrerequisite();
        m_metaData=new DepthMetaData();
        return true;
	}

 public void Paint(DepthMetaData depthMeta, WriteableBitmap b)
 {
     if (b.Format == PixelFormats.Gray16)
         PaintGray16(b, depthMeta);
     else if (b.Format == PixelFormats.Pbgra32)
         PaintPbgra32(b, depthMeta);
 }

        private NuiSource()
        {
            this.context = new Context("openni.xml");

            // Initialise generators
            this.imageGenerator = this.context.FindExistingNode(NodeType.Image) as ImageGenerator;
            this.depthGenerator = this.context.FindExistingNode(NodeType.Depth) as DepthGenerator;
            this.depthGenerator.GetAlternativeViewPointCap().SetViewPoint(this.imageGenerator);

            this.userGenerator = new UserGenerator(this.context);
            this.imageMetadata = new ImageMetaData();
            var imageMapMode = this.imageGenerator.GetMapOutputMode();

            this.depthMetadata = new DepthMetaData();
            var depthMapMode = this.depthGenerator.GetMapOutputMode();
            this.depthHistogram = new int[this.depthGenerator.GetDeviceMaxDepth()];

            // Initialise bitmaps
            this.cameraImage = new WriteableBitmap(
                (int)imageMapMode.nXRes, (int)imageMapMode.nYRes, 96, 96, PixelFormats.Rgb24, null);
            this.depthImage = new WriteableBitmap(
                (int)depthMapMode.nXRes, (int)depthMapMode.nYRes, 96, 96, PixelFormats.Rgb24, null);

            // Initialise user generator
            this.userGenerator.NewUser += this.UserGenerator_NewUser;
            this.userGenerator.LostUser += this.UserGenerator_LostUser;
            this.userGenerator.StartGenerating();
            this.ShowPlayerLabels = true;

            // Initialise background thread
            var cameraThread = new Thread(this.CameraThread) { IsBackground = true };
            cameraThread.Start();
        }

        private NuiSource()
        {
            context = new Context("openni.xml");

            // Initialise generators
            imageGenerator = this.context.FindExistingNode(NodeType.Image) as ImageGenerator;
            depthGenerator = this.context.FindExistingNode(NodeType.Depth) as DepthGenerator;

            imageMetadata = new ImageMetaData();
            var imageMapMode = imageGenerator.GetMapOutputMode();

            depthMetadata = new DepthMetaData();
            var depthMapMode = depthGenerator.GetMapOutputMode();
            depthHistogram = new int[depthGenerator.GetDeviceMaxDepth()];

            // Initialise bitmaps
            cameraImage = new WriteableBitmap((int)imageMapMode.nXRes, (int)imageMapMode.nYRes, 96, 96, PixelFormats.Rgb24, null);
            depthImage = new WriteableBitmap((int)depthMapMode.nXRes, (int)depthMapMode.nYRes, 96, 96, PixelFormats.Rgb24, null);

            // Initialise background thread
            var cameraThread = new Thread(this.CameraThread) { IsBackground = true };
            cameraThread.Start();

            var userGenerator = new UserGenerator(context);
            userGenerator.NewUser += this.UserGenerator_NewUser;
            userGenerator.LostUser += this.UserGenerator_LostUser;
        }

        static void Run()
        {
            string SAMPLE_XML_FILE = @"../../../Data/SamplesConfig.xml";

            ScriptNode scriptNode;
            Context context = Context.CreateFromXmlFile(SAMPLE_XML_FILE, out scriptNode);

            DepthGenerator depth = context.FindExistingNode(NodeType.Depth) as DepthGenerator;
            if (depth == null)
            {
                Console.WriteLine("Sample must have a depth generator!");
                return;
            }

            MapOutputMode mapMode = depth.MapOutputMode;

            DepthMetaData depthMD = new DepthMetaData();

            Console.WriteLine("Press any key to stop...");

            while (!Console.KeyAvailable)
            {
                context.WaitOneUpdateAll(depth);

                depth.GetMetaData(depthMD);

                Console.WriteLine("Frame {0} Middle point is: {1}.", depthMD.FrameID, depthMD[(int)mapMode.XRes/2, (int)mapMode.YRes/2]);
            }
        }

        private void PaintGray16(WriteableBitmap b, DepthMetaData depthMeta)
        {
            b.Lock();

            short* pDepthRow = (short*) depthMeta.DepthMapPtr;

            int nTexMapX = b.BackBufferStride / (b.Format.BitsPerPixel / 8);
            short* pTexRow = (short*) b.BackBuffer + depthMeta.YOffset*nTexMapX;

            for (int y = 0; y < depthMeta.YRes; y++)
            {
                short* pDepth = pDepthRow;
                short* pTex = pTexRow + depthMeta.XOffset;

                for (int x = 0; x < depthMeta.XRes; x++)
                {
                    if (*pDepth != 0)
                    {
                        *pTex = (short) _depthHist[*pDepth];
                    }
                    else
                    {
                        *pTex = 0;
                    }

                    pDepth++;
                    pTex++;
                }
                pDepthRow += depthMeta.XRes;
                pTexRow += nTexMapX;
            }

            b.AddDirtyRect(new Int32Rect(0, 0, b.PixelWidth, b.PixelHeight));
            b.Unlock();
        }

        // ヒストグラムの計算
        private unsafe void CalcHist(DepthMetaData depthMD)
        {
            for (int i = 0; i < histogram.Length; ++i) {
            histogram[i] = 0;
              }

              ushort* pDepth = (ushort*)depthMD.DepthMapPtr.ToPointer();

              int points = 0;
              for (int y = 0; y < depthMD.YRes; ++y) {
            for (int x = 0; x < depthMD.XRes; ++x, ++pDepth) {
              ushort depthVal = *pDepth;
              if (depthVal != 0) {
            histogram[depthVal]++;
            points++;
              }
            }
              }

              for (int i = 1; i < histogram.Length; i++) {
            histogram[i] += histogram[i - 1];
              }

              if (points > 0) {
            for (int i = 1; i < histogram.Length; i++) {
              histogram[i] = (int)(256 * (1.0f - (histogram[i] / (float)points)));
            }
              }
        }

        public void Start()
        {
            this.context = new Context (SAMPLE_XML_FILE);
            this.depth = context.FindExistingNode (NodeType.Depth) as DepthGenerator;
            if (this.depth == null) {
                throw new Exception ("Viewer must have a depth node!");
            }

            this.depthMD = new DepthMetaData ();
            this.histogram = new int[this.depth.GetDeviceMaxDepth ()];
        }

        public unsafe void GetDepthData(DepthMetaData depthMD, out byte[] data)
        {
            data = new byte[this.depthMD.XRes * this.depthMD.YRes * 3];

            ushort* pDepth = (ushort*)this.depthMD.DepthMapPtr.ToPointer ();

            int index = 0;
            for (int y = 0; y < depthMD.YRes; y++) {
                for (int x = 0; x < depthMD.XRes; x++,pDepth++) {
                    byte pixel = (byte)this.histogram[*pDepth];
                    data[index] = pixel;
                    data[index + 1] = pixel;
                    data[index + 2] = pixel;
                    index += 3;
                }
            }
        }

        public static unsafe void FillTexture(DepthMetaData depthMD, out ushort[] bytes)
        {
            ushort* pDepth = (ushort*)depthMD.DepthMapPtr.ToPointer();

              bytes = new ushort[depthMD.XRes * depthMD.YRes];

              int points = 0;
              for (int y = 0; y < depthMD.YRes; ++y) {
              for (int x = 0; x < depthMD.XRes; ++x, ++pDepth) {
              ushort depthVal = *pDepth;
              //if (depthVal != 0) {
              bytes[points] = depthVal;
              points++;
              //}
              }
              }

              StreamWriter sw = File.CreateText("/Users/matt/Desktop/CustomCodeLog.txt");
              sw.WriteLine("XRes: #{0}", depthMD.XRes);
              sw.WriteLine("YRes: #{0}", depthMD.YRes);
              sw.WriteLine("bytes[100]: #{0}", (int)(256 * bytes[100]));
              sw.Close();
        }

        //Starts up necessary files to take data
        //Must run before TakeData()
        Kinect()
        {
            //Sets locations of XML File
            string SAMPLE_XML_FILE = @"..\\..\\..\\SamplesConfig.xml";

            //Declares object of ScriptNode and defines context
            ScriptNode scriptNode;
            context = Context.CreateFromXmlFile(SAMPLE_XML_FILE, out scriptNode);

            //Declares the depth generator
            depth = context.FindExistingNode(NodeType.Depth) as DepthGenerator;
            //If the depth generator does not exist returns error messag
            if (depth == null)
            {
                Console.WriteLine("Sample must have a depth generator!");
                Console.ReadLine();
                return;
            }
            //Declares necessary variables and classes to take depth
            //DepthGenerator depth = context.FindExistingNode(NodeType.Depth) as DepthGenerator;
            mapMode = depth.MapOutputMode;
            depthMD = new DepthMetaData();
        }

        public void Update(DepthMetaData depthMeta)
        {
            if (_depthHist == null)
                _depthHist = new float[MaxDepth];

            Array.Clear(_depthHist, 0, _depthHist.Length);

            int numPoints = 0;

            short* ptrDepth = (short*)depthMeta.DepthMapPtr;
            for (int y = 0; y < depthMeta.YRes; y++)
            {
                for (int x = 0; x < depthMeta.XRes; x++)
                {
                    if (*ptrDepth != 0)
                    {
                        _depthHist[*ptrDepth]++;
                        numPoints++;
                    }
                    ptrDepth++;
                }
            }

            for (int i = 1; i < MaxDepth; i++)
            {
                _depthHist[i] += _depthHist[i - 1];
            }

            if (numPoints > 0)
            {
                for (int nIndex = 1; nIndex < MaxDepth; nIndex++)
                {
                    _depthHist[nIndex] = Int16.MaxValue * (1.0f - (_depthHist[nIndex] / numPoints));
                }
            }
        }

 /// <summary>
 /// Draw the image from the depth sensor with optional background subtraction
 /// or user markers to the <see cref="Image"/>-property.
 /// </summary>
 /// <param name="background_users">Users to regard as background.</param>
 protected unsafe void drawDepthWithHighlightAndBackgroundSubtraction(
     DepthMetaData depthMD, ushort[] userInformationMap,
     bool drawBackground, bool drawHighlight, int[] histogram,
     List<int> background_users)
 {
     fixed (ushort* userInformation = userInformationMap)
     {
         drawDepthWithHighlightAndBackgroundSubtraction(
             depthMD, userInformation, drawBackground, drawHighlight,
             histogram, background_users);
     }
 }

        /// <summary>
        /// Draw the image from the depth sensor without optional background subtraction
        /// or user markers to the <see cref="Image"/>-property.
        /// </summary>
        protected unsafe void drawDepthWithoutHighlightAndBackgroundSubtraction(
            DepthMetaData depthMD, int[] histogram)
        {
            // Create a depth histogram.
            CalcHist(depthMD, histogram);

            BitmapData data = bitmap.LockBits(rect, ImageLockMode.ReadWrite,
                        System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            double depthMax = (float)depthGenerator.DeviceMaxDepth;

#if PARALELLIZED
            // Otherwise Parallelization does not work.
            bitmap.UnlockBits(data);

            Parallel.For(0, depthMD.YRes, (y) =>
            {
                ushort* pDepth = (ushort*)this.depthGenerator.DepthMapPtr.ToPointer() + y * depthMD.XRes;
                byte* pDest = (byte*)data.Scan0.ToPointer() + y * data.Stride;
                for (int x = 0; x < depthMD.XRes; ++x, pDest += 3, pDepth++)
                {
                    pDest[0] = pDest[1] = pDest[2] = 0;

                    //byte pixel = (byte)((*pDepth) / depthMax * 255.0);
                    byte pixel = (byte)histogram[*pDepth];
                    pDest[2] = pixel;
                    pDest[1] = pixel;
                    pDest[0] = pixel;
                }
            });
#else
            try
            {
                byte pixel;
                // set pixels
                for (int y = 0; y < depthMD.YRes; ++y)
                {
                    byte* pDest = (byte*)data.Scan0.ToPointer() + y * data.Stride;
                    for (int x = 0; x < depthMD.XRes; ++x, pDest += 3, pDepth++)
                    {
                        pDest[0] = pDest[1] = pDest[2] = 0;

                        //pixel = ((*pDepth) / depthMax * 255.0);
                        pixel = (byte)histogram[*pDepth];
                        pDest[2] = pixel;
                        pDest[1] = pixel;
                        pDest[0] = pixel;
                    }
                }
            }
            finally
            { bitmap.UnlockBits(data); }
#endif
        }

 public void GetMetaData(DepthMetaData depthMD)
 {
     using (IMarshaler marsh = depthMD.GetMarshaler(true))
     {
         OpenNIImporter.xnGetDepthMetaData(this.InternalObject, marsh.Native);
     }
 }

        private unsafe void ReaderThread()
        {
            DepthMetaData depthMD = new DepthMetaData();

            while (this.shouldRun)
            {
                try
                {
                    this.context.WaitOneUpdateAll(this.depth);
                }
                catch (Exception)
                {
                }

                this.depth.GetMetaData(depthMD);

                CalcHist(depthMD);

                lock (this)
                {
                    Rectangle rect = new Rectangle(0, 0, this.bitmap.Width, this.bitmap.Height);
                    BitmapData data = this.bitmap.LockBits(rect, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

                    ushort* pDepth = (ushort*)this.depth.DepthMapPtr.ToPointer();

                    // set pixels
                    for (int y = 0; y < depthMD.YRes; ++y)
                    {
                        byte* pDest = (byte*)data.Scan0.ToPointer() + y * data.Stride;
                        for (int x = 0; x < depthMD.XRes; ++x, ++pDepth, pDest += 3)
                        {
                            byte pixel = (byte)this.histogram[*pDepth];
                            pDest[0] = 0;
                            pDest[1] = pixel;
                            pDest[2] = pixel;
                        }
                    }

                    this.bitmap.UnlockBits(data);
                }

                this.Invalidate();
            }
        }

        private unsafe void ReaderThread()
        {
            DepthMetaData depthMD = new DepthMetaData();

            while (this.shouldRun)
            {
                try
                {
                    this.context.WaitOneUpdateAll(this.depth);
                }
                catch (Exception)
                {
                }

                this.depth.GetMetaData(depthMD);

                CalcHist(depthMD);

                lock (this)
                {
                    Rectangle rect = new Rectangle(0, 0, this.bitmap.Width, this.bitmap.Height);
                    BitmapData data = this.bitmap.LockBits(rect, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

                    if (this.shouldDrawPixels)
                    {
                        ushort* pDepth = (ushort*)this.depth.DepthMapPtr.ToPointer();
                        ushort* pLabels = (ushort*)this.userGenerator.GetUserPixels(0).LabelMapPtr.ToPointer();

                        // set pixels
                        for (int y = 0; y < depthMD.YRes; ++y)
                        {
                            byte* pDest = (byte*)data.Scan0.ToPointer() + y * data.Stride;
                            for (int x = 0; x < depthMD.XRes; ++x, ++pDepth, ++pLabels, pDest += 3)
                            {
                                pDest[0] = pDest[1] = pDest[2] = 0;

                                ushort label = *pLabels;
                                if (this.shouldDrawBackground || *pLabels != 0)
                                {
                                    Color labelColor = Color.White;
                                    if (label != 0)
                                    {
                                        labelColor = colors[label % ncolors];
                                    }

                                    byte pixel = (byte)this.histogram[*pDepth];
                                    pDest[0] = (byte)(pixel * (labelColor.B / 256.0));
                                    pDest[1] = (byte)(pixel * (labelColor.G / 256.0));
                                    pDest[2] = (byte)(pixel * (labelColor.R / 256.0));
                                }
                            }
                        }
                    }
                    this.bitmap.UnlockBits(data);

                    Graphics g = Graphics.FromImage(this.bitmap);
                    int[] users = this.userGenerator.GetUsers();
                    foreach (int user in users)
                    {
                        if (this.shouldPrintID)
                        {
                            Point3D com = this.userGenerator.GetCoM(user);
                            com = this.depth.ConvertRealWorldToProjective(com);

                            string label = "";
                            if (!this.shouldPrintState)
                                label += user;
                            else if (this.skeletonCapbility.IsTracking(user))
                                label += user + " - Tracking";
                            else if (this.skeletonCapbility.IsCalibrating(user))
                                label += user + " - Calibrating...";
                            else
                                label += user + " - Looking for pose";

                            g.DrawString(label, new Font("Arial", 6), new SolidBrush(anticolors[user % ncolors]), com.X, com.Y);

                        }

                        if (this.shouldDrawSkeleton && this.skeletonCapbility.IsTracking(user))
            //                        if (this.skeletonCapbility.IsTracking(user))
                            DrawSkeleton(g, anticolors[user % ncolors], user);

                    }
                    g.Dispose();
                }

                this.Invalidate();
            }
        }

 public void GetMetaData(DepthMetaData depthMD)
 {
     using (IMarshaler marsh = depthMD.GetMarshaler(true))
     {
         SafeNativeMethods.xnGetDepthMetaData(this.InternalObject, marsh.Native);
     }
 }

 public void SetData(DepthMetaData depthMD)
 {
     SetData(depthMD, depthMD.FrameID, depthMD.Timestamp);
 }

        public bool initializeSensor(String xmlPath)
        {
            try

            {

                pbuffer =new  Point[6];
                openpalm = new OpenPalm();
                scrHeight = SystemInformation.PrimaryMonitorSize.Height;
                scrWidth = SystemInformation.PrimaryMonitorSize.Width;

                mouseSpeed = SystemInformation.MouseSpeed * 0.15;
                pointCollections = new PointCollection();
                /*OpenNI objects - Context, DepthGenerator and DepthMetaData are initialized here*/
                cxt = new Context(xmlPath);
                depthGen = cxt.FindExistingNode(NodeType.Depth) as DepthGenerator;
                gsHandsGenerator = cxt.FindExistingNode(NodeType.Hands) as HandsGenerator;
                gsHandsGenerator.SetSmoothing(0.1f);
                depthMeta = new DepthMetaData();
                if (depthGen == null) return false;

                xRes = depthGen.MapOutputMode.XRes;
                yRes = depthGen.MapOutputMode.YRes;

                /*NITE objects - Session manager, PointControl is initialized here*/
                sessionMgr = new SessionManager(cxt, "Wave", "RaiseHand");

                pointCtrl = new PointControl("PointTracker");
                steadydetector = new SteadyDetector();
                flrouter = new FlowRouter();
                brodcaster = new Broadcaster();
                steadydetector.DetectionDuration = 200;

                steadydetector.Steady+=new EventHandler<SteadyEventArgs>(steadydetector_Steady);
                steadydetector.NotSteady+=new EventHandler<SteadyEventArgs>(steadydetector_NotSteady);
              /*  pointCtrl.PrimaryPointCreate += new EventHandler<HandFocusEventArgs>(pointCtrl_PrimaryPointCreate);
                pointCtrl.PrimaryPointUpdate += new EventHandler<HandEventArgs>(pointCtrl_PrimaryPointUpdate);
                pointCtrl.PrimaryPointDestroy += new EventHandler<IdEventArgs>(pointCtrl_PrimaryPointDestroy);*/
                pointCtrl.PointCreate += new EventHandler<HandEventArgs>(pointCtrl_PointCreate);
                pointCtrl.PointUpdate += new EventHandler<HandEventArgs>(pointCtrl_PointUpdate);
                pointCtrl.PointDestroy += new EventHandler<IdEventArgs>(pointCtrl_PointDestroy);

                sessionMgr.AddListener(steadydetector);
               sessionMgr.AddListener(pointCtrl);  //make the session manager listen to the point control

                isActive = false;                   //set lifecycle flag to false
                            //fill the handpoint coordinates with invalid values
                         //initialize the clipping matrix

                HandPointBuffer = new ArrayList();

            }
            catch (Exception e) { return false; }

            return true;
        }