public Resize()
        {
            // cvResize
            // 指定した出力画像サイズに合うように、入力画像のサイズを変更し出力する．

            // (1)画像を読み込む
            using (IplImage src = new IplImage(Const.ImageSquare5, LoadMode.AnyColor | LoadMode.AnyDepth))
            {
                // (2)出力用画像領域の確保を行なう
                CvSize size = new CvSize(src.Width * 2, src.Height * 2);
                using (IplImage dstNN = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstCubic = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstLinear = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstLanczos = new IplImage(size, src.Depth, src.NChannels))                
                {
                    // (3)画像のサイズ変更を行う
                    Cv.Resize(src, dstNN, Interpolation.NearestNeighbor);
                    Cv.Resize(src, dstCubic, Interpolation.Cubic);                    
                    Cv.Resize(src, dstLinear, Interpolation.Linear);
                    Cv.Resize(src, dstLanczos, Interpolation.Lanczos4);

                    // (4)結果を表示する
                    using (new CvWindow("src", src))
                    using (new CvWindow("dst NearestNeighbor", dstNN))
                    using (new CvWindow("dst Cubic", dstCubic))
                    using (new CvWindow("dst Linear", dstLinear))
                    using (new CvWindow("dst Lanczos4", dstLanczos))                    
                    {
                        Cv.WaitKey();
                    }
                }
            }
        }

        public FitLine()
        {
            CvSize imageSize = new CvSize(500, 500);

            // cvFitLine
            CvPoint2D32f[] points = GetRandomPoints(20, imageSize);
            CvLine2D line = Cv.FitLine2D(points, DistanceType.L2, 0, 0.01, 0.01);

            using (IplImage img = new IplImage(imageSize, BitDepth.U8, 3))
            {
                img.Zero();

                // draw line
                {
                    CvPoint pt1, pt2;
                    line.FitSize(img.Width, img.Height, out pt1, out pt2);
                    img.Line(pt1, pt2, CvColor.Green, 1, LineType.Link8);
                }

                // draw points and distances
                using (CvFont font = new CvFont(FontFace.HersheySimplex, 0.33, 0.33))
                {
                    foreach (CvPoint2D32f p in points)
                    {
                        double d = line.Distance(p);

                        img.Circle(p, 2, CvColor.White, -1, LineType.AntiAlias);
                        img.PutText(string.Format("{0:F1}", d), new CvPoint((int) (p.X + 3), (int) (p.Y + 3)), font, CvColor.Green);
                    }
                }

                CvWindow.ShowImages(img);
            }
        }

        public 描画画面()
        {
            InitializeComponent();

            dis_height= System.Windows.Forms.Screen.PrimaryScreen.Bounds.Height;
            dis_width=System.Windows.Forms.Screen.PrimaryScreen.Bounds.Width;
            pos_max = Tobii.pos_max;
            while (Tobii. 眼球位置_L[0] == 0 || Tobii. 眼球位置_R[0] == 100) { }//両目とれるまでここにとどまる
            diff_in = Tobii. 眼球位置_R[0]-Tobii. 眼球位置_L[0];
            posY_in = (Tobii.眼球位置_L[1] + Tobii.眼球位置_R[1] )/ 2;

            pictureBoxIpl1.Width = dis_width;
            pictureBoxIpl1.Height = dis_height;
            frame = Cv.CreateImage(new CvSize(dis_width, dis_height), BitDepth.U8, 3);
            background = Cv.CreateImage(new CvSize(dis_width, dis_height), BitDepth.U8, 3);
            background=メイン画面.background;
            pictureBoxIpl1.ImageIpl = background;
            window_size = new CvSize(メイン画面.window[0], メイン画面.window[1]);
            point_old = new CvPoint(window_size.Width / 2, window_size.Height / 2);
            許容半径 = メイン画面.radius;

            PC=new System.Diagnostics.PerformanceCounter[3];

            タイマー開始();
        }

        public Resize()
        {
            using (var src = new IplImage(FilePath.Image.Square5, LoadMode.AnyColor | LoadMode.AnyDepth))
            {
                CvSize size = new CvSize(src.Width * 2, src.Height * 2);
                using (IplImage dstNN = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstCubic = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstLinear = new IplImage(size, src.Depth, src.NChannels))
                using (IplImage dstLanczos = new IplImage(size, src.Depth, src.NChannels))                
                {
                    Cv.Resize(src, dstNN, Interpolation.NearestNeighbor);
                    Cv.Resize(src, dstCubic, Interpolation.Cubic);                    
                    Cv.Resize(src, dstLinear, Interpolation.Linear);
                    Cv.Resize(src, dstLanczos, Interpolation.Lanczos4);

                    using (new CvWindow("src", src))
                    using (new CvWindow("dst NearestNeighbor", dstNN))
                    using (new CvWindow("dst Cubic", dstCubic))
                    using (new CvWindow("dst Linear", dstLinear))
                    using (new CvWindow("dst Lanczos4", dstLanczos))                    
                    {
                        Cv.WaitKey();
                    }
                }
            }
        }

        private void CaptureCameraCallback()
        {
            const double ScaleFactor = 2.5;
            const int MinNeighbors = 1;
            CvSize MinSize = new CvSize(30, 30);

            CvCapture cap = CvCapture.FromCamera(1);
            CvHaarClassifierCascade cascade = CvHaarClassifierCascade.FromFile("haarcascade_eye.xml");
            while (true)
            {
                IplImage img = cap.QueryFrame();
                //IplImage.FromBitmap()
                //CvSeq<CvAvgComp> eyes = Cv.HaarDetectObjects(img, cascade, Cv.CreateMemStorage(), ScaleFactor, MinNeighbors, HaarDetectionType.DoCannyPruning, MinSize);
                
                //foreach (CvAvgComp eye in eyes.AsParallel())
                //{
                //    img.DrawRect(eye.Rect, CvColor.Red);

                //    if (eye.Rect.Left > pctCvWindow.Width / 2)
                //    {
                //        try
                //        {
                //            IplImage rightEyeImg1 = img.Clone();
                //            Cv.SetImageROI(rightEyeImg1, eye.Rect);
                //            IplImage rightEyeImg2 = Cv.CreateImage(eye.Rect.Size, rightEyeImg1.Depth, rightEyeImg1.NChannels);
                //            Cv.Copy(rightEyeImg1, rightEyeImg2, null);
                //            Cv.ResetImageROI(rightEyeImg1);

                            
                //            Bitmap rightEyeBm = BitmapConverter.ToBitmap(rightEyeImg2);
                //            pctRightEye.Image = rightEyeBm;
                //        }
                //        catch { }
                //    }
                //    else
                //    {
                //        try
                //        {
                //            IplImage leftEyeImg1 = img.Clone();
                //            Cv.SetImageROI(leftEyeImg1, eye.Rect);
                //            IplImage leftEyeImg2 = Cv.CreateImage(eye.Rect.Size, leftEyeImg1.Depth, leftEyeImg1.NChannels);
                //            Cv.Copy(leftEyeImg1, leftEyeImg2, null);
                //            Cv.ResetImageROI(leftEyeImg1);

                //            Bitmap leftEyeBm = BitmapConverter.ToBitmap(leftEyeImg2);
                //            pctLeftEye.Image = leftEyeBm;
                //        }catch{}
                //    }
                //}

                Bitmap bm = BitmapConverter.ToBitmap(img);
                bm.SetResolution(pctCvWindow.Width, pctCvWindow.Height);
                //pctCvWindow.Image = bm;
                pb.Image = bm;
                img = null;
                bm = null;
                Thread.Sleep(100);
            }
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="_modelPoints"></param>
 /// <param name="_modelSize"></param>
 /// <param name="_maxBasicSolutions"></param>
 public CvModelEstimator2(int _modelPoints, CvSize _modelSize, int _maxBasicSolutions)
 {
     modelPoints = _modelPoints;
     modelSize = _modelSize;
     maxBasicSolutions = _maxBasicSolutions;
     checkPartialSubsets = true;
     rng = new CvRNG(-1);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="modelPoints"></param>
 /// <param name="modelSize"></param>
 /// <param name="maxBasicSolutions"></param>
 protected CvModelEstimator2(int modelPoints, CvSize modelSize, int maxBasicSolutions)
 {
     this.modelPoints = modelPoints;
     this.modelSize = modelSize;
     this.maxBasicSolutions = maxBasicSolutions;
     this.checkPartialSubsets = true;
     this.rng = new CvRNG(-1);
 }

 /// <summary>
 /// Конструктор
 /// </summary>
 /// <param name="size">Размер обрабатываемого изображения</param>
 public ContoursFinder(CvSize size)
 {
     this.size = size;
     hsvImg = new IplImage(size, BitDepth.U8, 3);
     hImg = new IplImage(size, BitDepth.U8, 1);
     sImg = new IplImage(size, BitDepth.U8, 1);
     vImg = new IplImage(size, BitDepth.U8, 1);
     tmpImg = new IplImage(size, BitDepth.U8, 1);
 }

        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="deviceId">ID камеры с которой будут захватываться кадры</param>
        /// <param name="frameSize">Желаемое разрешение кадров</param>
        public WebCam(int deviceId, CvSize frameSize)
        {
            this.deviceId = deviceId;
            vi = new VideoInput();
            vi.SetupDevice(deviceId, frameSize.Width, frameSize.Height);

            this.frameSize = new CvSize(vi.GetWidth(deviceId), vi.GetHeight(deviceId));
            sum = new IplImage(this.frameSize, BitDepth.F32, 3);
            tmp = new IplImage(this.frameSize, BitDepth.U8, 3);
        }

        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="deviceId">ID камеры которая будет использоваться для получения изображения</param>
        /// <param name="frameSize">Размер изображения которое будет обрабатываться</param>
        public ImageProcessingRoutine(int deviceId, CvSize frameSize)
        {
            Camera = new WebCam(deviceId, frameSize);
            Calibrator = new CameraCalibrator(Camera.FrameSize);
            Finder = new ContoursFinder(Camera.FrameSize);
            Transformer = new CoordinatesTransformer();

            routineThread = new Thread(routine);
            routineThread.IsBackground = true;
            routineThread.Start();
        }

        private void OnClick_csv出力(object sender, EventArgs e)
        {
            if (合成画像 != null)
            {
                string 結果 = "";
                int x,y;
                int roi_w = 9;
                int roi_h = 9;

                CvSize roiSize = new CvSize(roi_w, roi_h);
                CvPoint roiPoint;
                for (x = 0; x < 合成画像.Width - roi_w; x++)
                {
                    System.Diagnostics.Debug.WriteLine(x + "\n" + 結果);

                    for (y = 0; y < 合成画像.Height - roi_h; y++)
                    {
                        string buff = "";
                        string type = 検査領域か判断(x,y,roi_w,roi_h);

                        if (type != "")//ちょっと高速化
                        {
                            roiPoint = new CvPoint(x, y);
                            Cv.SetImageROI(検査対象, new CvRect(roiPoint, roiSize));
                            if (type == "1") buff = csvフォーマットを取得(検査対象, roiSize, "1");
                            else if (type == "0") buff = csvフォーマットを取得(検査対象, roiSize, "0");
                        }
                        //if (checkBox_all.Checked)
                        //{
                        //    roiPoint = new CvPoint(x, y);
                        //    Cv.SetImageROI(検査対象, new CvRect(roiPoint, roiSize));
                        //    Cv.SetImageROI(マスク画像, new CvRect(roiPoint, roiSize));
                        //    if (マスク画像.Avg().Val0 == 0) buff = csvフォーマットを取得(検査対象, roiSize, "0");
                        //    else if (マスク画像.Avg().Val0 == 255) buff = csvフォーマットを取得(検査対象, roiSize, "1");
                        //}
                        //else if (checkBox_black.Checked)
                        //{
                        //    if (マスク画像.Avg().Val0 == 0) buff = csvフォーマットを取得(検査対象, roiSize, "0");
                        //}
                        //else
                        //{
                        //    if (マスク画像.Avg().Val0 == 255) buff = csvフォーマットを取得(検査対象, roiSize, "1");
                        //}

                        if(buff!="")結果 += buff + "\n";

                        Cv.ResetImageROI(マスク画像);
                        Cv.ResetImageROI(検査対象);
                    }
                }
                stringをcsv出力(結果,DateTime.Now.ToString("yy-MM-dd_")+this.Text);
            }
        }

 private CvPoint2D32f[] GetRandomPoints(int count, CvSize imageSize)
 {
     Random rand = new Random();
     CvPoint2D32f[] points = new CvPoint2D32f[count];
     double a = rand.NextDouble() + 0.5;
     for (int i = 0; i < points.Length; i++)
     {
         double x = rand.Next(imageSize.Width);
         double y = (x * a) + (rand.Next(100) - 50);
         points[i] = new CvPoint2D32f(x, y);
     }
     return points;
 }

        private Point GetOverlapLocation(Bitmap screan)
        {
            IplImage ipltemplate = BitmapConverter.ToIplImage(template);
            IplImage iplScrean = BitmapConverter.ToIplImage(screan);

            CvSize resSize = new CvSize(iplScrean.Width - ipltemplate.Width + 1,
                                        iplScrean.Height - ipltemplate.Height + 1);
            IplImage resImg = Cv.CreateImage(resSize, BitDepth.F32, 1);

            Cv.MatchTemplate(iplScrean, ipltemplate, resImg, MatchTemplateMethod.CCorrNormed);

            double minVal;
            double maxVal;
            CvPoint minLoc;
            CvPoint maxLoc;
            Cv.MinMaxLoc(resImg, out minVal, out maxVal, out minLoc, out maxLoc);
            return maxVal >= 0.99 ? new Point(maxLoc.X, maxLoc.Y) : new Point(0, 0);
        }

    /* ------------------------- */



    // Use this for initialization
    void Start()
    {
        // 変数宣言
        int x_window = GlobalVar.CAMERA_WIDTH;
        int y_window = GlobalVar.CAMERA_HEIGHT;

        // カメラデバイス選択、設定
        cam1.setDevice(0);  // 水平
        cam2.setDevice(1);  // 垂直

        // HSV画像初期化
        CvSize WINDOW_SIZE = new CvSize(x_window, y_window);
        h_img1 = Cv.CreateImage(WINDOW_SIZE, BitDepth.U8, 3);
        h_img2 = Cv.CreateImage(WINDOW_SIZE, BitDepth.U8, 3);

        // データ格納用配列の初期化
        int x = x_window / GlobalVar.POINT_INTERVAL;
        int y = y_window / GlobalVar.POINT_INTERVAL;
        int z = y_window / GlobalVar.POINT_INTERVAL;
        hps_arr  = new int[y, x];
        vps_arr  = new int[z, x];
        ps_arr3D = new int[x, y, z];
        pl_arrXZ = new double[GlobalVar.VERTICE_NUM / 2, 2];
        pl_arrY  = new double[2];
        io_flag  = new int[x, y, z];    // 外部（遠）:0 外部（近）:1 内部:2

        // 3Dポリゴン指定
        refObj = GameObject.Find("Object");
        polygon = refObj.GetComponent<CreatePolygonMesh>();
        polygon.Init();

        // 観測点データ初期化
        init3DArr(ps_arr3D);
        initMFlag(io_flag);

        // 図形と観測点の内部外部判定を行う
        polygon.getIODMonitoringPoint(io_flag);
        
        /*     デバッグ用（FPS）     */
        frameCount = 0;
        prevTime = 0.0f;
        /* ------------------------- */
    }

    /* ------------------ */

    // Use this for initialization
    void Start()
    {
        // カメラデバイスの選択、設定
        cam.setDevice(index);

        // HSV用画像の初期化
        CvSize WINDOW_SIZE = new CvSize(GlobalVar.CAMERA_WIDTH, GlobalVar.CAMERA_HEIGHT);
        h_img = Cv.CreateImage(WINDOW_SIZE, BitDepth.U8, 3);

        // データ格納用配列の初期化
        ps_arr = new int[GlobalVar.CAMERA_HEIGHT / GlobalVar.POINT_INTERVAL, GlobalVar.CAMERA_WIDTH / GlobalVar.POINT_INTERVAL];

        /*     デバッグ用     */
        CvSize D_WINDOW_SIZE = new CvSize(GlobalVar.CAMERA_WIDTH, GlobalVar.CAMERA_HEIGHT);
        d_img = Cv.CreateImage(D_WINDOW_SIZE, BitDepth.U8, 3);
        texture = new Texture2D(GlobalVar.CAMERA_WIDTH, GlobalVar.CAMERA_HEIGHT, TextureFormat.RGB24, false);
        GetComponent<Renderer>().material.mainTexture = texture;
        /* ------------------ */
    }

        string csvフォーマットを取得(IplImage src, CvSize size,string type)
        {
            string info = "";
            double 平均, 分散;

            平均 = src.Avg().Val0;
            double sum = 0, max = 0, min = 255;
            for (int x = 0; x < size.Width; x++)
                for (int y = 0; y < size.Height; y++)
                {
                    //CvScalar cs = Cv.Get2D(src, y, x);
                    double val = Cv.Get2D(src, y, x).Val0;
                    sum += Math.Pow(val - 平均, 2);
                    if (val > max) max = val;
                    if (val < min) min = val;
                }
            分散 = sum / (size.Width * size.Height);
            info = 平均.ToString("f")+","+分散.ToString("f")+","+max.ToString("f")+","+min.ToString("f")+","+type;

            return info;
        }

        void Awake()
        {
            _cap = new CvCapture(0);

            _capImage = _cap.QueryFrame();
            _capRgbImage = new IplImage(_capImage.Width, _capImage.Height, BitDepth.U8, 3);
            Debug.Log(string.Format("Capture info : size{0}", _capImage.Size));
               	_capGrayImage0 = new IplImage(_capImage.Size, BitDepth.U8, 1);
            _capGrayImage1 = new IplImage(_capImage.Size, BitDepth.U8, 1);
            _pyramidImage0 = new IplImage(new CvSize(_capImage.Width + 8, _capImage.Height/3), BitDepth.U8, 1);
            _pyramidImage1 = new IplImage(new CvSize(_capImage.Width + 8, _capImage.Height/3), BitDepth.U8, 1);
            _eigImage = new IplImage(_capImage.Size, BitDepth.F32, 1);
            _tmpImage = new IplImage(_capImage.Size, BitDepth.F32, 1);
            Cv.ConvertImage(_capImage, _capGrayImage0, 0);
            width = _capImage.Width;
            height = _capImage.Height;

            _opticalFlowWinSize = new CvSize(opticalFlowWinSize, opticalFlowWinSize);
            _opticalFlowCrit = new CvTermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, ofCritIterations, ofCritError);

            _prevTime = _currTime = UnityEngine.Time.time;
        }

        /// <summary>
        /// 楕円弧をポリラインで近似する
        /// </summary>
        /// <param name="center">弧の中心</param>
        /// <param name="axes">楕円の軸の長さ</param>
        /// <param name="angle">楕円の回転角度</param>
        /// <param name="arc_start">楕円弧の開始角度</param>
        /// <param name="arc_end">楕円弧の終了角度</param>
        /// <param name="pts">この関数で塗りつぶされる点の配列</param>
        /// <param name="delta">ポリラインの連続した頂点間の角度，近似精度．出力される点の総数は最大で ceil((end_angle - start_angle)/delta) + 1．</param>
        /// <returns></returns>
#else
        /// <summary>
        /// Approximates elliptic arc with polyline
        /// </summary>
        /// <param name="center">Center of the arc. </param>
        /// <param name="axes">Half-sizes of the arc. See cvEllipse. </param>
        /// <param name="angle">Rotation angle of the ellipse in degrees. See cvEllipse. </param>
        /// <param name="arc_start">Starting angle of the elliptic arc. </param>
        /// <param name="arc_end">Ending angle of the elliptic arc. </param>
        /// <param name="pts">The array of points, filled by the function. </param>
        /// <param name="delta">Angle between the subsequent polyline vertices, approximation accuracy. So, the total number of output points will ceil((end_angle - start_angle)/delta) + 1 at max. </param>
        /// <returns>The function cvEllipse2Poly computes vertices of the polyline that approximates the specified elliptic arc. It is used by cvEllipse. It returns the numbers of output points.</returns>
#endif
        public static int Ellipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start, int arc_end, out CvPoint[] pts, int delta)
        {
            int nb_pts = (int)Math.Ceiling(((arc_end - arc_start) / (float)delta) + 1);
            pts = new CvPoint[nb_pts];
            nb_pts = CvInvoke.cvEllipse2Poly(center, axes, angle, arc_start, arc_end, pts, delta);
            //pts = new CvPoint[nb_pts];
            //Array.ConstrainedCopy(pts2, 0, pts, 0, nb_pts);       
            return nb_pts;
        }

        /// <summary>
        /// 枠だけの楕円，もしくは塗りつぶされた楕円を描画する
        /// </summary>
        /// <param name="img">楕円が描かれる画像．</param>
        /// <param name="box">描画したい楕円を囲む矩形領域．</param>
        /// <param name="color">楕円の色．</param>
        /// <param name="thickness">楕円境界線の幅．</param>
        /// <param name="line_type">楕円境界線の種類．</param>
        /// <param name="shift">矩形領域の頂点座標の小数点以下の桁を表すビット数．</param>
#else
        /// <summary>
        /// Draws simple or thick elliptic arc or fills ellipse sector
        /// </summary>
        /// <param name="img">Image. </param>
        /// <param name="box">The enclosing box of the ellipse drawn </param>
        /// <param name="color">Ellipse color. </param>
        /// <param name="thickness">Thickness of the ellipse boundary. </param>
        /// <param name="line_type">Type of the ellipse boundary</param>
        /// <param name="shift">Number of fractional bits in the box vertex coordinates. </param>
#endif
        public static void EllipseBox(CvArr img, CvBox2D box, CvScalar color, int thickness, LineType line_type, int shift)
        {
            if (img == null)
            {
                throw new ArgumentNullException("img");
            }

            CvSize axes = new CvSize
            {
                Width = (int)Math.Round(box.Size.Height * 0.5),
                Height = (int)Math.Round(box.Size.Width * 0.5)
            };
            Ellipse(img, box.Center, axes, box.Angle, 0, 360, color, thickness, line_type, shift);
        }

        /// <summary>
        /// 枠だけの楕円，楕円弧，もしくは塗りつぶされた扇形の楕円を描画する
        /// </summary>
        /// <param name="img">楕円が描画される画像</param>
        /// <param name="center">楕円の中心</param>
        /// <param name="axes">楕円の軸の長さ</param>
        /// <param name="angle">回転角度</param>
        /// <param name="start_angle">楕円弧の開始角度</param>
        /// <param name="end_angle">楕円弧の終了角度</param>
        /// <param name="color">楕円の色</param>
        /// <param name="thickness">楕円弧の線の幅</param>
        /// <param name="line_type">楕円弧の線の種類</param>
        /// <param name="shift">中心座標と軸の長さの小数点以下の桁を表すビット数</param>
#else
        /// <summary>
        /// Draws simple or thick elliptic arc or fills ellipse sector
        /// </summary>
        /// <param name="img">Image. </param>
        /// <param name="center">Center of the ellipse. </param>
        /// <param name="axes">Length of the ellipse axes. </param>
        /// <param name="angle">Rotation angle. </param>
        /// <param name="start_angle">Starting angle of the elliptic arc. </param>
        /// <param name="end_angle">Ending angle of the elliptic arc. </param>
        /// <param name="color">Ellipse color. </param>
        /// <param name="thickness">Thickness of the ellipse arc. </param>
        /// <param name="line_type">Type of the ellipse boundary.</param>
        /// <param name="shift">Number of fractional bits in the center coordinates and axes' values. </param>
#endif
        public static void DrawEllipse(CvArr img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, LineType line_type, int shift)
        {
            Ellipse(img, center, axes, angle, start_angle, end_angle, color, thickness, line_type, shift);
        }