/**
  * この関数は、ラスタドライバから画像を読み出します。
  * @param i_pix_drv
  * @param i_size
  * @param i_vertex
  * @param o_data
  * @param o_param
  * @return
  * @
  */
 public bool pickFromRaster(INyARGsPixelDriver i_pix_drv, NyARIntPoint2d[] i_vertex, NyIdMarkerPattern o_data, NyIdMarkerParam o_param)
 {
     if (!this._perspective_reader.setSourceSquare(i_vertex))
     {
         return false;
     }
     return this._pickFromRaster(i_pix_drv, o_data, o_param);
 }

 /**
  * 4近傍の画素ベクトルを取得します。
  * 0,1,0
  * 1,x,1
  * 0,1,0
  * @param i_raster
  * @param x
  * @param y
  * @param o_v
  */
 public void getPixelVector4(int x, int y, NyARIntPoint2d o_v)
 {
     int[] buf = this._ref_buf;
     int w = this._ref_size.w;
     int idx = w * y + x;
     o_v.x = buf[idx + 1] - buf[idx - 1];
     o_v.y = buf[idx + w] - buf[idx - w];
 }

 /**
  * この関数は、ラスタドライバから画像を読み出します。
  * @param i_pix_drv
  * @param i_size
  * @param i_vertex
  * @param o_data
  * @param o_param
  * @return
  * @throws NyARException
  */
 public bool getARPlayCardId(INyARGsPixelDriver i_pix_drv, NyARIntPoint2d[] i_vertex, PsArIdParam i_result)
 {
     if (!this._perspective_reader.setSourceSquare(i_vertex))
     {
         return false;
     }
     return this._pickFromRaster(i_pix_drv, i_result);
 }

 public static void copyArray(NyARIntPoint2d[] i_from, NyARIntPoint2d[] i_to)
 {
     for (int i = i_from.Length - 1; i >= 0; i--)
     {
         i_to[i].x = i_from[i].x;
         i_to[i].y = i_from[i].y;
     }
     return;
 }

 /**
  * 配列ファクトリ
  * @param i_number
  * @return
  */
 public static NyARIntPoint2d[] createArray(int i_number)
 {
     NyARIntPoint2d[] ret = new NyARIntPoint2d[i_number];
     for (int i = 0; i < i_number; i++)
     {
         ret[i] = new NyARIntPoint2d();
     }
     return ret;
 }

 /**
  * 8近傍画素ベクトル
  * 1,2,1
  * 2,x,2
  * 1,2,1
  * @param i_raster
  * @param x
  * @param y
  * @param o_v
  */
 public void getPixelVector8(int x, int y, NyARIntPoint2d o_v)
 {
     int[] buf = this._ref_buf;
     NyARIntSize s = this._ref_size;
     int idx_0 = s.w * y + x;
     int idx_p1 = idx_0 + s.w;
     int idx_m1 = idx_0 - s.w;
     int b = buf[idx_m1 - 1];
     int d = buf[idx_m1 + 1];
     int h = buf[idx_p1 - 1];
     int f = buf[idx_p1 + 1];
     o_v.x = buf[idx_0 + 1] - buf[idx_0 - 1] + (d - b + f - h) / 2;
     o_v.y = buf[idx_p1] - buf[idx_m1] + (f - d + h - b) / 2;
 }

        public pickFromRaster_N(NyARIntPoint2d i_lt, int i_resolution, NyARIntSize i_source_size)
        {
            this._lt_ref = i_lt;
            this._resolution = i_resolution;
            this._size_ref = i_source_size;

            this._rgb_temp = new int[i_resolution * i_resolution * 3];
            this._rgb_px = new int[i_resolution * i_resolution];
            this._rgb_py = new int[i_resolution * i_resolution];

            this._cp1cy_cp2 = new double[i_resolution];
            this._cp4cy_cp5 = new double[i_resolution];
            this._cp7cy_1 = new double[i_resolution];
            return;
        }

        public bool traceConture(int i_th,
			    NyARIntPoint2d i_entry, VecLinearCoordinates o_coord)
	    {
		    NyARIntCoordinates coord = this._coord_buf;
		    // Robertsラスタから輪郭抽出
		    if (!this._cpickup.getContour(this._ref_rob_raster, i_th, i_entry.x, i_entry.y,
				    coord)) {
			    // 輪郭線MAXならなにもできないね。
			    return false;

		    }
		    // 輪郭線のベクトル化
		    return traceConture(coord, this._rob_resolution,
				    this._rob_resolution * 2, o_coord);
	    }

 /**
  * [readonly]マーカにマッチした{@link NyARMatchPattDeviationColorData}インスタンスを得る。
  * @ 
  */
 public NyARMatchPattDeviationColorData getDeviationColorData(ARMarkerList.Item i_marker, INyARPerspectiveCopy i_pix_drv, NyARIntPoint2d[] i_vertex)
 {
     int mk_edge = i_marker.patt_edge_percentage;
     for (int i = this.items.Count - 1; i >= 0; i--)
     {
         Item ptr = this.items[i];
         if (!ptr._patt.getSize().isEqualSize(i_marker.patt_w, i_marker.patt_h) || ptr._patt_edge != mk_edge)
         {
             //サイズとエッジサイズが合致しない物はスルー
             continue;
         }
         //古かったら更新
         i_pix_drv.copyPatt(i_vertex, ptr._patt_edge, ptr._patt_edge, ptr._patt_resolution, ptr._patt);
         ptr._patt_d.setRaster(ptr._patt);
         return ptr._patt_d;
     }
     //無い。新しく生成
     Item item = new Item(i_marker.patt_w, i_marker.patt_h, mk_edge);
     //タイムスタンプの更新とデータの生成
     i_pix_drv.copyPatt(i_vertex, item._patt_edge, item._patt_edge, item._patt_resolution, item._patt);
     item._patt_d.setRaster(item._patt);
     this.items.Add(item);
     return item._patt_d;
 }

 /**
  * この関数は、遠近法のパラメータを計算して、返却します。
  * @param i_width
  * 変換先の矩形のサイズを指定します。
  * @param i_height
  * 変換先の矩形のサイズを指定します。
  * @param i_vertex
  * 変換元の頂点を指定します。要素数は4でなければなりません。
  * @param o_param
  * 射影変換パラメータの出力インスタンスを指定します。要素数は8でなければなりません。
  * @return
  * 成功するとtrueを返します。
  * @
  */
 public bool getParam(int i_width, int i_height, NyARIntPoint2d[] i_vertex, double[] o_param)
 {
     return this.getParam(i_width, i_height, i_vertex[0].x, i_vertex[0].y, i_vertex[1].x, i_vertex[1].y, i_vertex[2].x, i_vertex[2].y, i_vertex[3].x, i_vertex[3].y, o_param);
 }

 /**
  * この関数は、直線を矩形でクリッピングしたときの、端点を計算します。
  * @param i_left
  * 矩形の左上座標(X)
  * @param i_top
  * 矩形の左上座標(Y)
  * @param i_width
  * 矩形の幅
  * @param i_height
  * 矩形の高さ
  * @param o_point
  * 端点を返すオブジェクト配列。2要素である必要があります。
  * @return
  * 端点が求まればtrue
  */
 public bool makeSegmentLine(int i_left, int i_top, int i_width, int i_height, NyARIntPoint2d[] o_point)
 {
     int bottom = i_top + i_height;
     int right = i_left + i_width;
     int idx = 0;
     NyARIntPoint2d ptr = o_point[0];
     if (this.crossPos(0, -1, i_top, ptr) && ptr.x >= i_left && ptr.x < right)
     {
         //y=rect.yの線
         idx++;
         ptr = o_point[idx];
     }
     if (this.crossPos(0, -1, bottom - 1, ptr) && ptr.x >= i_left && ptr.x < right)
     {
         //y=(rect.y+rect.h-1)の線
         idx++;
         if (idx == 2)
         {
             return true;
         }
         ptr = o_point[idx];
     }
     if (this.crossPos(-1, 0, i_left, ptr) && ptr.y >= i_top && ptr.y < bottom)
     {
         //x=i_leftの線
         idx++;
         if (idx == 2)
         {
             return true;
         }
         ptr = o_point[idx];
     }
     if (this.crossPos(-1, 0, right - 1, ptr) && ptr.y >= i_top && ptr.y < bottom)
     {
         //x=i_right-1の線
         idx++;
         if (idx == 2)
         {
             return true;
         }
     }
     return false;
 }

 /**
  * この関数は、2点を結ぶ直線式を計算して、インスタンスに格納します。
  * 式の係数値は、正規化されます。
  * @param i_point1
  * 点１
  * @param i_point2
  * 点２
  * @return
  * 直線式が求まれば、true
  */
 public bool makeLinearWithNormalize(NyARIntPoint2d i_point1, NyARIntPoint2d i_point2)
 {
     return makeLinearWithNormalize(i_point1.x, i_point1.y, i_point2.x, i_point2.y);
 }

 public void setValue(NyARIntPoint2d i_src)
 {
     this.x = (double)i_src.x;
     this.y = (double)i_src.y;
     return;
 }

 /**
  * この関数は、２つの座標点配列同士の距離値を一括してマップにセットします。
  * <p>
  * 実装メモ - 
  * 点のフォーマットが合わない場合は、この関数参考にオーバーロードしてください。
  * </p>
  * @param i_vertex_r
  * 比較する頂点群を格納した配列。
  * @param i_row_len
  * i_vertex_rの有効な要素数
  * @param i_vertex_c
  * 基準となる頂点群を格納した配列
  * @param i_col_len
  * i_vertex_cの有効な要素数
  */
 public void setPointDists(NyARIntPoint2d[] i_vertex_r, int i_row_len, NyARIntPoint2d[] i_vertex_c, int i_col_len)
 {
     DistItem[] map = this._map;
     //distortionMapを作成。ついでに最小値のインデクスも取得
     int min_index = 0;
     int min_dist = int.MaxValue;
     int idx = 0;
     for (int r = 0; r < i_row_len; r++)
     {
         for (int c = 0; c < i_col_len; c++)
         {
             map[idx].col = c;
             map[idx].row = r;
             int d = i_vertex_r[r].sqDist(i_vertex_c[c]);
             map[idx].dist = d;
             if (min_dist > d)
             {
                 min_index = idx;
                 min_dist = d;
             }
             idx++;
         }
     }
     this._min_dist = min_dist;
     this._min_dist_index = min_index;
     this._size_col = i_col_len;
     this._size_row = i_row_len;
     return;
 }

 /**
  * 座標値を射影変換します。
  * @param i_x
  * 変換元の座標値
  * @param i_y
  * 変換元の座標値
  * @param i_z
  * 変換元の座標値
  * @param o_2d
  * 変換後の座標値を受け取るオブジェクト
  */
 public void project(double i_x, double i_y, double i_z, NyARIntPoint2d o_2d)
 {
     double w = 1 / (i_z * this.m22);
     o_2d.x = (int)((i_x * this.m00 + i_y * this.m01 + i_z * this.m02) * w);
     o_2d.y = (int)((i_y * this.m11 + i_z * this.m12) * w);
     return;
 }

        /**
         * i_imageから、idマーカを読みだします。
         * o_dataにはマーカデータ、o_paramにはまーかのパラメータを返却します。
         * @param image
         * @param i_square
         * @param o_data
         * @param o_param
         * @return
         * @throws NyARException
         */
        public bool pickFromRaster(INyARRgbRaster image, NyARIntPoint2d[] i_vertex, NyIdMarkerPattern o_data, NyIdMarkerParam o_param)
        {
            //遠近法のパラメータを計算
            if (!this._perspective_reader.setSourceSquare(i_vertex))
            {
                return false;
            };

            INyARRgbPixelReader reader = image.getRgbPixelReader();
            NyARIntSize raster_size = image.getSize();


            PerspectivePixelReader.TThreshold th = this.__pickFromRaster_th;
            MarkerPattEncoder encoder = this.__pickFromRaster_encoder;
            //マーカパラメータを取得
            this._perspective_reader.detectThresholdValue(reader, raster_size, th);

            if (!this._perspective_reader.readDataBits(reader, raster_size,th, encoder))
            {
                return false;
            }
            int d = encoder.encode(o_data);
            if (d < 0)
            {
                return false;
            }
            o_param.direction = d;
            o_param.threshold = th.th;

            return true;
        }

 private bool getHighPixelCenter(int i_st, int[] i_pixels, int i_width, int i_height, int i_th, NyARIntPoint2d o_point)
 {
     int rp = i_st;
     int pos_x = 0;
     int pos_y = 0;
     int number_of_pos = 0;
     for (int i = 0; i < i_height; i++)
     {
         for (int i2 = 0; i2 < i_width; i2++)
         {
             if (i_pixels[rp++] > i_th)
             {
                 pos_x += i2;
                 pos_y += i;
                 number_of_pos++;
             }
         }
     }
     if (number_of_pos > 0)
     {
         pos_x /= number_of_pos;
         pos_y /= number_of_pos;
     }
     else
     {
         return false;
     }
     o_point.x = pos_x;
     o_point.y = pos_y;
     return true;
 }

        public override bool getParam(NyARIntPoint2d[] i_vertex, double[] o_param)
        {
            double ltx = this._local_x;
            double lty = this._local_y;
            double rbx = ltx + this._width;
            double rby = lty + this._height;

            double det_1;
            double a13, a14, a23, a24, a33, a34, a43, a44;
            double b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44;
            double t1, t2, t3, t4, t5, t6;
            double v1, v2, v3, v4;
            double kx0, kx1, kx2, kx3, kx4, kx5, kx6, kx7;
            double ky0, ky1, ky2, ky3, ky4, ky5, ky6, ky7;
            {
                v1 = i_vertex[0].x;
                v2 = i_vertex[1].x;
                v3 = i_vertex[2].x;
                v4 = i_vertex[3].x;
                a13 = -ltx * v1;
                a14 = -lty * v1;
                a23 = -rbx * v2;
                a24 = -lty * v2;
                a33 = -rbx * v3;
                a34 = -rby * v3;
                a43 = -ltx * v4;
                a44 = -rby * v4;

                t1 = a33 * a44 - a34 * a43;
                t4 = a34 * ltx - rbx * a44;
                t5 = rbx * a43 - a33 * ltx;
                t2 = rby * (a34 - a44);
                t3 = rby * (a43 - a33);
                t6 = rby * (rbx - ltx);

                b21 = -a23 * t4 - a24 * t5 - rbx * t1;
                b11 = (a23 * t2 + a24 * t3) + lty * t1;
                b31 = (a24 * t6 - rbx * t2) + lty * t4;
                b41 = (-rbx * t3 - a23 * t6) + lty * t5;

                t1 = a43 * a14 - a44 * a13;
                t2 = a44 * lty - rby * a14;
                t3 = rby * a13 - a43 * lty;
                t4 = ltx * (a44 - a14);
                t5 = ltx * (a13 - a43);
                t6 = ltx * (lty - rby);

                b12 = -rby * t1 - a33 * t2 - a34 * t3;
                b22 = (a33 * t4 + a34 * t5) + rbx * t1;
                b32 = (-a34 * t6 - rby * t4) + rbx * t2;
                b42 = (-rby * t5 + a33 * t6) + rbx * t3;

                t1 = a13 * a24 - a14 * a23;
                t4 = a14 * rbx - ltx * a24;
                t5 = ltx * a23 - a13 * rbx;
                t2 = lty * (a14 - a24);
                t3 = lty * (a23 - a13);
                t6 = lty * (ltx - rbx);

                b23 = -a43 * t4 - a44 * t5 - ltx * t1;
                b13 = (a43 * t2 + a44 * t3) + rby * t1;
                b33 = (a44 * t6 - ltx * t2) + rby * t4;
                b43 = (-ltx * t3 - a43 * t6) + rby * t5;

                t1 = a23 * a34 - a24 * a33;
                t2 = a24 * rby - lty * a34;
                t3 = lty * a33 - a23 * rby;
                t4 = rbx * (a24 - a34);
                t5 = rbx * (a33 - a23);
                t6 = rbx * (rby - lty);

                b14 = -lty * t1 - a13 * t2 - a14 * t3;
                b24 = a13 * t4 + a14 * t5 + ltx * t1;
                b34 = -a14 * t6 - lty * t4 + ltx * t2;
                b44 = -lty * t5 + a13 * t6 + ltx * t3;

                det_1 = (ltx * (b11 + b14) + rbx * (b12 + b13));
                if (det_1 == 0)
                {
                    det_1 = 0.0001;
                    //System.out.println("Could not get inverse matrix(1).");					
                    //return false;
                }
                det_1 = 1 / det_1;

                kx0 = (b11 * v1 + b12 * v2 + b13 * v3 + b14 * v4) * det_1;
                kx1 = (b11 + b12 + b13 + b14) * det_1;
                kx2 = (b21 * v1 + b22 * v2 + b23 * v3 + b24 * v4) * det_1;
                kx3 = (b21 + b22 + b23 + b24) * det_1;
                kx4 = (b31 * v1 + b32 * v2 + b33 * v3 + b34 * v4) * det_1;
                kx5 = (b31 + b32 + b33 + b34) * det_1;
                kx6 = (b41 * v1 + b42 * v2 + b43 * v3 + b44 * v4) * det_1;
                kx7 = (b41 + b42 + b43 + b44) * det_1;
            }
            {
                v1 = i_vertex[0].y;
                v2 = i_vertex[1].y;
                v3 = i_vertex[2].y;
                v4 = i_vertex[3].y;
                a13 = -ltx * v1;
//.........这里部分代码省略.........

 public bool setSquare(NyARIntPoint2d[] i_vertex)
 {
     if (!this._param_gen.getParam(i_vertex, this._cparam))
     {
         return false;
     }
     return true;
 }

 public NyARDoublePoint2d(NyARIntPoint2d i_src)
 {
     this.x = (double)i_src.x;
     this.y = (double)i_src.y;
     return;
 }