Ejemplo n.º 1
0
        /// <summary>
        /// TODO: LDPoint注意
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="clip"></param>
        /// <returns></returns>
        public LDPoint inverseTransform(LDPoint pt, bool clip = false)
        {
            if (getColumn() == 0 && getRow() == 0)
            {
                //メッシュがない場合はそのままの値を返す
                return(pt);
            }

            double x = pt.x();
            double y = pt.y();


            //Gridからマッピング先のQuadを見つける
            LDPoint index = getMapedQuadIndex(new LDPoint((float)x, (float)y));
            int     col   = (int)index.x();
            int     row   = (int)index.y();

            if (clip)
            {
                //Grid内にClipする。QuadをClipして変換するのではない
                col = LDMathUtil.clamp(col, 0, getColumn());
                row = LDMathUtil.clamp(row, 0, getRow());
            }

            LDPoint local = new LDPoint();

            if (isOutside(row, col))
            {
                LDQuadTransform quad = createOutsideQuadTransform(row, col);
                return(quad.inverseTransform(pt, clip));

                //TODO:到達しない場所あります
                local = quad.inverseTransform(pt, clip);

                LDPoint _internal;
                _internal.setX((col + 1) * (1.0f / (getColumn() + 2)) + local.x() / (getColumn() + 2));
                _internal.setY((row + 1) * (1.0f / (getRow() + 2)) + local.y() / (getRow() + 2));

                LDQuadTransform tmp = new LDQuadTransform(new LDPoint(-1, -1), new LDPoint(getColumn() + 1, getRow() + 1));
                return(tmp.transform(_internal));
            }
            else
            {
                LDQuadTransform quad = getQuadTransform(row, col);
                local = quad.inverseTransform(pt, clip);

                LDPoint _internal = new LDPoint();
                _internal.setX(col * (1.0f / getColumn()) + local.x() / getColumn());
                _internal.setY(row * (1.0f / getRow()) + local.y() / getRow());

                return(_internal);
            }
        }
Ejemplo n.º 2
0
        public void inverseTransformTest()
        {
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));
                LDPoint src=new LDPoint(20, 15);

                LDPoint dst=new LDPoint();

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.25);
            }
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10), new LDPoint(20, 10), new LDPoint(100, 100), new LDPoint(10, 20));
                LDPoint src=new LDPoint(83.8f, 83.8f);

                LDPoint dst;

                dst = quad.inverseTransform(src);
                //		TestUtil.COMPARE(dst.x(),0.9);
                //		TestUtil.COMPARE(dst.y(),0.9);
                TestUtil.LDFUZZY_COMPARE(dst.x(), 0.9, 0.0000001);
                TestUtil.LDFUZZY_COMPARE(dst.y(), 0.9, 0.0000001);
            }
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));
                LDPoint src=new LDPoint(20, 25);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.75);
            }
            {
                //(0,0),(100,100)を90度回転
                LDQuadTransform quad=new LDQuadTransform(
                           new LDPoint(100, 0),
                           new LDPoint(100, 100),
                           new LDPoint(0, 100),
                           new LDPoint(0, 0)
                            );
                LDPoint src=new LDPoint(75, 50);

                LDPoint dst;

                dst = quad.inverseTransform(src);
                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.25);
            }

            {
                //大きめの数字
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(1024, 1024), new LDPoint(3500, 3500));
                LDPoint src=new LDPoint(2000, 2000);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.LDFUZZY_COMPARE(dst.x(), 0.394184, 0.00001);
                TestUtil.LDFUZZY_COMPARE(dst.y(), 0.394184, 0.00001);
            }
            {
                //斜め
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(20, 20),new LDPoint(20, 30),new LDPoint(10, 20));
                LDPoint src=new LDPoint(15, 20);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.5);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10.12345f, 10.12321f),new LDPoint(20.1102f, 20.034f),new LDPoint(20.11111f, 30.22222f), new LDPoint(10.232697f, 20.00008f));
                LDPoint src=new LDPoint(15.8731f, 20.5396f);

                LDPoint dst;
                LDPoint rest;
                dst = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(1023.12345f, 1041.12321f),new LDPoint(2075.1102, 2032.034),new LDPoint(2034.11111, 3061.22222),new LDPoint(1023.232697, 2088.00008));
                LDPoint src=new LDPoint(1515.8731, 2072.5396);

                LDPoint dst;
                LDPoint rest;
                dst = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
        }
Ejemplo n.º 3
0
        public void extendedTransformTest()
        {
            //範囲外補間

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));

                LDPoint src = new LDPoint(-1, -1);

                LDPoint dst;

                dst = quad.transform(src);

                TestUtil.COMPARE(dst.x(), -10.0);
                TestUtil.COMPARE(dst.y(), -10.0);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));

                LDPoint src = new LDPoint(-1, -1);

                LDPoint dst;

                dst = quad.transform(src, true);//範囲内にクリッピングする

                TestUtil.COMPARE(dst.x(), 10.0);
                TestUtil.COMPARE(dst.y(), 10.0);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));

                LDPoint src = new LDPoint(2, 2);

                LDPoint dst;

                dst = quad.transform(src);

                TestUtil.COMPARE(dst.x(), 50.0);
                TestUtil.COMPARE(dst.y(), 50.0);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));
                LDPoint         src  = new LDPoint(40, 40);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 1.5);
                TestUtil.COMPARE(dst.y(), 1.5);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));
                LDPoint         src  = new LDPoint(40, 40);

                LDPoint dst;

                dst = quad.inverseTransform(src, true);

                TestUtil.COMPARE(dst.x(), 1.0);
                TestUtil.COMPARE(dst.y(), 1.0);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10.12345, 10.12321), new LDPoint(20.1102, 20.034), new LDPoint(20.11111, 30.22222), new LDPoint(10.232697, 20.00008));
                LDPoint         src  = new LDPoint(45.8731, 60.5396);

                LDPoint dst;
                LDPoint rest;
                dst  = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(1023.12345, 1041.12321), new LDPoint(2075.1102, 2032.034), new LDPoint(2034.11111, 3061.22222), new LDPoint(1023.232697, 2088.00008));
                LDPoint         src  = new LDPoint(11515.8731, 62072.5396);

                LDPoint dst;
                LDPoint rest;
                dst  = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(1023.12345, 1041.12321), new LDPoint(2075.1102, 2032.034), new LDPoint(2034.11111, 3061.22222), new LDPoint(1023.232697, 2088.00008));
                LDPoint         src  = new LDPoint(5.8731, 72.5396);

                LDPoint dst;
                LDPoint rest;
                dst  = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
        }
Ejemplo n.º 4
0
        public void inverseTransformTest()
        {
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));
                LDPoint         src  = new LDPoint(20, 15);

                LDPoint dst = new LDPoint();

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.25);
            }
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(20, 10), new LDPoint(100, 100), new LDPoint(10, 20));
                LDPoint         src  = new LDPoint(83.8f, 83.8f);

                LDPoint dst;

                dst = quad.inverseTransform(src);
                //		TestUtil.COMPARE(dst.x(),0.9);
                //		TestUtil.COMPARE(dst.y(),0.9);
                TestUtil.LDFUZZY_COMPARE(dst.x(), 0.9, 0.0000001);
                TestUtil.LDFUZZY_COMPARE(dst.y(), 0.9, 0.0000001);
            }
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(30, 30));
                LDPoint         src  = new LDPoint(20, 25);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.75);
            }
            {
                //(0,0),(100,100)を90度回転
                LDQuadTransform quad = new LDQuadTransform(
                    new LDPoint(100, 0),
                    new LDPoint(100, 100),
                    new LDPoint(0, 100),
                    new LDPoint(0, 0)
                    );
                LDPoint src = new LDPoint(75, 50);

                LDPoint dst;

                dst = quad.inverseTransform(src);
                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.25);
            }

            {
                //大きめの数字
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(1024, 1024), new LDPoint(3500, 3500));
                LDPoint         src  = new LDPoint(2000, 2000);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.LDFUZZY_COMPARE(dst.x(), 0.394184, 0.00001);
                TestUtil.LDFUZZY_COMPARE(dst.y(), 0.394184, 0.00001);
            }
            {
                //斜め
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10, 10), new LDPoint(20, 20), new LDPoint(20, 30), new LDPoint(10, 20));
                LDPoint         src  = new LDPoint(15, 20);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 0.5);
                TestUtil.COMPARE(dst.y(), 0.5);
            }

            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(10.12345f, 10.12321f), new LDPoint(20.1102f, 20.034f), new LDPoint(20.11111f, 30.22222f), new LDPoint(10.232697f, 20.00008f));
                LDPoint         src  = new LDPoint(15.8731f, 20.5396f);

                LDPoint dst;
                LDPoint rest;
                dst  = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad = new LDQuadTransform(new LDPoint(1023.12345f, 1041.12321f), new LDPoint(2075.1102, 2032.034), new LDPoint(2034.11111, 3061.22222), new LDPoint(1023.232697, 2088.00008));
                LDPoint         src  = new LDPoint(1515.8731, 2072.5396);

                LDPoint dst;
                LDPoint rest;
                dst  = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
        }
Ejemplo n.º 5
-4
        public void extendedTransformTest()
        {
            //範囲外補間

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));

                LDPoint src=new LDPoint(-1, -1);

                LDPoint dst;

                dst = quad.transform(src);

                TestUtil.COMPARE(dst.x(), -10.0);
                TestUtil.COMPARE(dst.y(), -10.0);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));

                LDPoint src=new LDPoint(-1, -1);

                LDPoint dst;

                dst = quad.transform(src, true);//範囲内にクリッピングする

                TestUtil.COMPARE(dst.x(), 10.0);
                TestUtil.COMPARE(dst.y(), 10.0);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));

                LDPoint src=new LDPoint(2, 2);

                LDPoint dst;

                dst = quad.transform(src);

                TestUtil.COMPARE(dst.x(), 50.0);
                TestUtil.COMPARE(dst.y(), 50.0);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));
                LDPoint src= new LDPoint(40, 40);

                LDPoint dst;

                dst = quad.inverseTransform(src);

                TestUtil.COMPARE(dst.x(), 1.5);
                TestUtil.COMPARE(dst.y(), 1.5);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10, 10),new LDPoint(30, 30));
                LDPoint src=new LDPoint(40, 40);

                LDPoint dst;

                dst = quad.inverseTransform(src, true);

                TestUtil.COMPARE(dst.x(), 1.0);
                TestUtil.COMPARE(dst.y(), 1.0);
            }

            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(10.12345, 10.12321), new LDPoint(20.1102, 20.034), new LDPoint(20.11111, 30.22222), new LDPoint(10.232697, 20.00008));
                LDPoint src=new LDPoint(45.8731, 60.5396);

                LDPoint dst;
                LDPoint rest;
                dst = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(1023.12345, 1041.12321), new LDPoint(2075.1102, 2032.034), new LDPoint(2034.11111, 3061.22222), new LDPoint(1023.232697, 2088.00008));
                LDPoint src=new LDPoint(11515.8731, 62072.5396);

                LDPoint dst;
                LDPoint rest;
                dst = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
            {
                LDQuadTransform quad=new LDQuadTransform(new LDPoint(1023.12345, 1041.12321), new LDPoint(2075.1102, 2032.034), new LDPoint(2034.11111, 3061.22222), new LDPoint(1023.232697, 2088.00008));
                LDPoint src=new LDPoint(5.8731, 72.5396);

                LDPoint dst;
                LDPoint rest;
                dst = quad.inverseTransform(src);
                rest = quad.transform(dst);

                TestUtil.LDFUZZY_COMPARE(src.x(), rest.x(), 0.0000001);
                TestUtil.LDFUZZY_COMPARE(src.y(), rest.y(), 0.0000001);
            }
        }