internal Envelope2DBucketSortHelper(com.epl.geometry.Envelope2DIntersectorImpl intersector, bool b_red)
 {
     // For
     // bucket
     // sort
     m_intersector = intersector;
     m_b_red       = b_red;
 }
        internal static com.epl.geometry.Envelope2DIntersectorImpl GetEnvelope2DIntersectorForParts(com.epl.geometry.MultiPathImpl multipathImplA, com.epl.geometry.MultiPathImpl multipathImplB, double tolerance, bool bExteriorOnlyA, bool bExteriorOnlyB)
        {
            int type_a = multipathImplA.GetType().Value();
            int type_b = multipathImplB.GetType().Value();

            com.epl.geometry.Envelope2D env_a = new com.epl.geometry.Envelope2D();
            com.epl.geometry.Envelope2D env_b = new com.epl.geometry.Envelope2D();
            multipathImplA.QueryLooseEnvelope2D(env_a);
            multipathImplB.QueryLooseEnvelope2D(env_b);
            env_a.Inflate(tolerance, tolerance);
            env_b.Inflate(tolerance, tolerance);
            com.epl.geometry.Envelope2D envInter = new com.epl.geometry.Envelope2D();
            envInter.SetCoords(env_a);
            envInter.Intersect(env_b);
            com.epl.geometry.Envelope2DIntersectorImpl intersector = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector.SetTolerance(tolerance);
            bool b_found_red = false;

            intersector.StartRedConstruction();
            for (int ipath_a = 0, npaths = multipathImplA.GetPathCount(); ipath_a < npaths; ipath_a++)
            {
                if (bExteriorOnlyA && type_a == com.epl.geometry.Geometry.GeometryType.Polygon && !multipathImplA.IsExteriorRing(ipath_a))
                {
                    continue;
                }
                multipathImplA.QueryPathEnvelope2D(ipath_a, env_a);
                if (!env_a.IsIntersecting(envInter))
                {
                    continue;
                }
                b_found_red = true;
                intersector.AddRedEnvelope(ipath_a, env_a);
            }
            intersector.EndRedConstruction();
            if (!b_found_red)
            {
                return(null);
            }
            bool b_found_blue = false;

            intersector.StartBlueConstruction();
            for (int ipath_b = 0, npaths = multipathImplB.GetPathCount(); ipath_b < npaths; ipath_b++)
            {
                if (bExteriorOnlyB && type_b == com.epl.geometry.Geometry.GeometryType.Polygon && !multipathImplB.IsExteriorRing(ipath_b))
                {
                    continue;
                }
                multipathImplB.QueryPathEnvelope2D(ipath_b, env_b);
                if (!env_b.IsIntersecting(envInter))
                {
                    continue;
                }
                b_found_blue = true;
                intersector.AddBlueEnvelope(ipath_b, env_b);
            }
            intersector.EndBlueConstruction();
            if (!b_found_blue)
            {
                return(null);
            }
            return(intersector);
        }
        internal static com.epl.geometry.Envelope2DIntersectorImpl GetEnvelope2DIntersector(com.epl.geometry.MultiPathImpl multipathImplA, com.epl.geometry.MultiPathImpl multipathImplB, double tolerance)
        {
            com.epl.geometry.Envelope2D env_a = new com.epl.geometry.Envelope2D();
            com.epl.geometry.Envelope2D env_b = new com.epl.geometry.Envelope2D();
            multipathImplA.QueryLooseEnvelope2D(env_a);
            multipathImplB.QueryLooseEnvelope2D(env_b);
            env_a.Inflate(tolerance, tolerance);
            env_b.Inflate(tolerance, tolerance);
            com.epl.geometry.Envelope2D envInter = new com.epl.geometry.Envelope2D();
            envInter.SetCoords(env_a);
            envInter.Intersect(env_b);
            com.epl.geometry.SegmentIteratorImpl       segIterA    = multipathImplA.QuerySegmentIterator();
            com.epl.geometry.SegmentIteratorImpl       segIterB    = multipathImplB.QuerySegmentIterator();
            com.epl.geometry.Envelope2DIntersectorImpl intersector = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector.SetTolerance(tolerance);
            bool b_found_red = false;

            intersector.StartRedConstruction();
            while (segIterA.NextPath())
            {
                while (segIterA.HasNextSegment())
                {
                    com.epl.geometry.Segment segmentA = segIterA.NextSegment();
                    segmentA.QueryEnvelope2D(env_a);
                    if (!env_a.IsIntersecting(envInter))
                    {
                        continue;
                    }
                    b_found_red = true;
                    com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                    env.SetCoords(env_a);
                    intersector.AddRedEnvelope(segIterA.GetStartPointIndex(), env);
                }
            }
            intersector.EndRedConstruction();
            if (!b_found_red)
            {
                return(null);
            }
            bool b_found_blue = false;

            intersector.StartBlueConstruction();
            while (segIterB.NextPath())
            {
                while (segIterB.HasNextSegment())
                {
                    com.epl.geometry.Segment segmentB = segIterB.NextSegment();
                    segmentB.QueryEnvelope2D(env_b);
                    if (!env_b.IsIntersecting(envInter))
                    {
                        continue;
                    }
                    b_found_blue = true;
                    com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                    env.SetCoords(env_b);
                    intersector.AddBlueEnvelope(segIterB.GetStartPointIndex(), env);
                }
            }
            intersector.EndBlueConstruction();
            if (!b_found_blue)
            {
                return(null);
            }
            return(intersector);
        }
        public static void TestEnvelope2Dintersector()
        {
            System.Collections.Generic.List <com.epl.geometry.Envelope2D> envelopes = new System.Collections.Generic.List <com.epl.geometry.Envelope2D>(0);
            com.epl.geometry.Envelope2D env0  = new com.epl.geometry.Envelope2D(2, 3, 4, 4);
            com.epl.geometry.Envelope2D env1  = new com.epl.geometry.Envelope2D(5, 13, 9, 15);
            com.epl.geometry.Envelope2D env2  = new com.epl.geometry.Envelope2D(6, 9, 11, 12);
            com.epl.geometry.Envelope2D env3  = new com.epl.geometry.Envelope2D(8, 10, 9, 17);
            com.epl.geometry.Envelope2D env4  = new com.epl.geometry.Envelope2D(11.001, 12, 14, 14);
            com.epl.geometry.Envelope2D env5  = new com.epl.geometry.Envelope2D(1, 3, 3, 4);
            com.epl.geometry.Envelope2D env6  = new com.epl.geometry.Envelope2D(0, 2, 5, 10);
            com.epl.geometry.Envelope2D env7  = new com.epl.geometry.Envelope2D(4, 7, 5, 10);
            com.epl.geometry.Envelope2D env8  = new com.epl.geometry.Envelope2D(3, 15, 15, 15);
            com.epl.geometry.Envelope2D env9  = new com.epl.geometry.Envelope2D(0, 9, 14, 9);
            com.epl.geometry.Envelope2D env10 = new com.epl.geometry.Envelope2D(0, 8.999, 14, 8.999);
            envelopes.Add(env0);
            envelopes.Add(env1);
            envelopes.Add(env2);
            envelopes.Add(env3);
            envelopes.Add(env4);
            envelopes.Add(env5);
            envelopes.Add(env6);
            envelopes.Add(env7);
            envelopes.Add(env8);
            envelopes.Add(env9);
            envelopes.Add(env10);
            com.epl.geometry.Envelope2DIntersectorImpl intersector = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector.SetTolerance(0.001);
            intersector.StartConstruction();
            for (int i = 0; i < envelopes.Count; i++)
            {
                intersector.AddEnvelope(i, envelopes[i]);
            }
            intersector.EndConstruction();
            int count = 0;

            while (intersector.Next())
            {
                int env_a = intersector.GetHandleA();
                int env_b = intersector.GetHandleB();
                count++;
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                env.SetCoords(envelopes[env_a]);
                env.Inflate(0.001, 0.001);
                NUnit.Framework.Assert.IsTrue(env.IsIntersecting(envelopes[env_b]));
            }
            System.Diagnostics.Debug.Assert((count == 16));
            com.epl.geometry.Envelope2DIntersectorImpl intersector2 = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector2.SetTolerance(0.0);
            intersector2.StartConstruction();
            for (int i_1 = 0; i_1 < envelopes.Count; i_1++)
            {
                intersector2.AddEnvelope(i_1, envelopes[i_1]);
            }
            intersector2.EndConstruction();
            count = 0;
            while (intersector2.Next())
            {
                int env_a = intersector2.GetHandleA();
                int env_b = intersector2.GetHandleB();
                count++;
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                env.SetCoords(envelopes[env_a]);
                NUnit.Framework.Assert.IsTrue(env.IsIntersecting(envelopes[env_b]));
            }
            System.Diagnostics.Debug.Assert((count == 13));
            env0 = new com.epl.geometry.Envelope2D(0, 0, 0, 10);
            env1 = new com.epl.geometry.Envelope2D(0, 10, 10, 10);
            env2 = new com.epl.geometry.Envelope2D(10, 0, 10, 10);
            env3 = new com.epl.geometry.Envelope2D(0, 0, 10, 0);
            envelopes.Clear();
            envelopes.Add(env0);
            envelopes.Add(env1);
            envelopes.Add(env2);
            envelopes.Add(env3);
            com.epl.geometry.Envelope2DIntersectorImpl intersector3 = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector3.SetTolerance(0.001);
            intersector3.StartConstruction();
            for (int i_2 = 0; i_2 < envelopes.Count; i_2++)
            {
                intersector3.AddEnvelope(i_2, envelopes[i_2]);
            }
            intersector3.EndConstruction();
            count = 0;
            while (intersector3.Next())
            {
                int env_a = intersector3.GetHandleA();
                int env_b = intersector3.GetHandleB();
                count++;
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                env.SetCoords(envelopes[env_a]);
                NUnit.Framework.Assert.IsTrue(env.IsIntersecting(envelopes[env_b]));
            }
            NUnit.Framework.Assert.IsTrue(count == 4);
            env0 = new com.epl.geometry.Envelope2D(0, 0, 0, 10);
            envelopes.Clear();
            envelopes.Add(env0);
            envelopes.Add(env0);
            envelopes.Add(env0);
            envelopes.Add(env0);
            com.epl.geometry.Envelope2DIntersectorImpl intersector4 = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector4.SetTolerance(0.001);
            intersector4.StartConstruction();
            for (int i_3 = 0; i_3 < envelopes.Count; i_3++)
            {
                intersector4.AddEnvelope(i_3, envelopes[i_3]);
            }
            intersector4.EndConstruction();
            count = 0;
            while (intersector4.Next())
            {
                int env_a = intersector4.GetHandleA();
                int env_b = intersector4.GetHandleB();
                count++;
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                env.SetCoords(envelopes[env_a]);
                NUnit.Framework.Assert.IsTrue(env.IsIntersecting(envelopes[env_b]));
            }
            System.Diagnostics.Debug.Assert((count == 6));
            env0 = new com.epl.geometry.Envelope2D(0, 10, 10, 10);
            envelopes.Clear();
            envelopes.Add(env0);
            envelopes.Add(env0);
            envelopes.Add(env0);
            envelopes.Add(env0);
            com.epl.geometry.Envelope2DIntersectorImpl intersector5 = new com.epl.geometry.Envelope2DIntersectorImpl();
            intersector5.SetTolerance(0.001);
            intersector5.StartConstruction();
            for (int i_4 = 0; i_4 < envelopes.Count; i_4++)
            {
                intersector5.AddEnvelope(i_4, envelopes[i_4]);
            }
            intersector5.EndConstruction();
            count = 0;
            while (intersector5.Next())
            {
                int env_a = intersector5.GetHandleA();
                int env_b = intersector5.GetHandleB();
                count++;
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                env.SetCoords(envelopes[env_a]);
                NUnit.Framework.Assert.IsTrue(env.IsIntersecting(envelopes[env_b]));
            }
            NUnit.Framework.Assert.IsTrue(count == 6);
        }
        public static void TestRandom()
        {
            int passcount   = 10;
            int figureSize  = 100;
            int figureSize2 = 100;

            com.epl.geometry.Envelope extent1 = new com.epl.geometry.Envelope();
            com.epl.geometry.Envelope extent2 = new com.epl.geometry.Envelope();
            com.epl.geometry.Envelope extent3 = new com.epl.geometry.Envelope();
            com.epl.geometry.Envelope extent4 = new com.epl.geometry.Envelope();
            extent1.SetCoords(-10000, 5000, 10000, 25000);
            // red
            extent2.SetCoords(-10000, 2000, 10000, 8000);
            // blue
            extent3.SetCoords(-10000, -8000, 10000, -2000);
            // blue
            extent4.SetCoords(-10000, -25000, 10000, -5000);
            // red
            com.epl.geometry.RandomCoordinateGenerator generator1 = new com.epl.geometry.RandomCoordinateGenerator(System.Math.Max(figureSize, 10000), extent1, 0.001);
            com.epl.geometry.RandomCoordinateGenerator generator2 = new com.epl.geometry.RandomCoordinateGenerator(System.Math.Max(figureSize, 10000), extent2, 0.001);
            com.epl.geometry.RandomCoordinateGenerator generator3 = new com.epl.geometry.RandomCoordinateGenerator(System.Math.Max(figureSize, 10000), extent3, 0.001);
            com.epl.geometry.RandomCoordinateGenerator generator4 = new com.epl.geometry.RandomCoordinateGenerator(System.Math.Max(figureSize, 10000), extent4, 0.001);
            System.Random random   = new System.Random(1982);
            int           rand_max = 511;
            int           qCount   = 0;
            int           eCount   = 0;
            int           bCount   = 0;

            for (int c = 0; c < passcount; c++)
            {
                com.epl.geometry.Polygon polyRed  = new com.epl.geometry.Polygon();
                com.epl.geometry.Polygon polyBlue = new com.epl.geometry.Polygon();
                int r = figureSize;
                if (r < 3)
                {
                    continue;
                }
                com.epl.geometry.Point pt;
                for (int j = 0; j < r; j++)
                {
                    int  rand       = random.Next(rand_max);
                    bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
                    pt = generator1.GetRandomCoord();
                    if (j == 0 || bRandomNew)
                    {
                        polyRed.StartPath(pt);
                    }
                    else
                    {
                        polyRed.LineTo(pt);
                    }
                }
                for (int j_1 = 0; j_1 < r; j_1++)
                {
                    int  rand       = random.Next(rand_max);
                    bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
                    pt = generator4.GetRandomCoord();
                    if (j_1 == 0 || bRandomNew)
                    {
                        polyRed.StartPath(pt);
                    }
                    else
                    {
                        polyRed.LineTo(pt);
                    }
                }
                r = figureSize2;
                if (r < 3)
                {
                    continue;
                }
                for (int j_2 = 0; j_2 < r; j_2++)
                {
                    int  rand       = random.Next(rand_max);
                    bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
                    pt = generator2.GetRandomCoord();
                    if (j_2 == 0 || bRandomNew)
                    {
                        polyBlue.StartPath(pt);
                    }
                    else
                    {
                        polyBlue.LineTo(pt);
                    }
                }
                for (int j_3 = 0; j_3 < r; j_3++)
                {
                    int  rand       = random.Next(rand_max);
                    bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
                    pt = generator3.GetRandomCoord();
                    if (j_3 == 0 || bRandomNew)
                    {
                        polyBlue.StartPath(pt);
                    }
                    else
                    {
                        polyBlue.LineTo(pt);
                    }
                }
                com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
                // Quad_tree
                com.epl.geometry.QuadTree quadTree = BuildQuadTree(polyBlue);
                com.epl.geometry.QuadTree.QuadTreeIterator iterator    = quadTree.GetIterator();
                com.epl.geometry.SegmentIteratorImpl       _segIterRed = ((com.epl.geometry.MultiPathImpl)polyRed._getImpl()).QuerySegmentIterator();
                while (_segIterRed.NextPath())
                {
                    while (_segIterRed.HasNextSegment())
                    {
                        com.epl.geometry.Segment segmentRed = _segIterRed.NextSegment();
                        segmentRed.QueryEnvelope2D(env);
                        iterator.ResetIterator(env, 0.001);
                        while (iterator.Next() != -1)
                        {
                            qCount++;
                        }
                    }
                }
                // Envelope_2D_intersector
                System.Collections.Generic.List <com.epl.geometry.Envelope2D> envelopes_red  = new System.Collections.Generic.List <com.epl.geometry.Envelope2D>();
                System.Collections.Generic.List <com.epl.geometry.Envelope2D> envelopes_blue = new System.Collections.Generic.List <com.epl.geometry.Envelope2D>();
                com.epl.geometry.SegmentIterator segIterRed = polyRed.QuerySegmentIterator();
                while (segIterRed.NextPath())
                {
                    while (segIterRed.HasNextSegment())
                    {
                        com.epl.geometry.Segment segment = segIterRed.NextSegment();
                        env = new com.epl.geometry.Envelope2D();
                        segment.QueryEnvelope2D(env);
                        envelopes_red.Add(env);
                    }
                }
                com.epl.geometry.SegmentIterator segIterBlue = polyBlue.QuerySegmentIterator();
                while (segIterBlue.NextPath())
                {
                    while (segIterBlue.HasNextSegment())
                    {
                        com.epl.geometry.Segment segment = segIterBlue.NextSegment();
                        env = new com.epl.geometry.Envelope2D();
                        segment.QueryEnvelope2D(env);
                        envelopes_blue.Add(env);
                    }
                }
                com.epl.geometry.Envelope2DIntersectorImpl intersector = new com.epl.geometry.Envelope2DIntersectorImpl();
                intersector.SetTolerance(0.001);
                intersector.StartRedConstruction();
                for (int i = 0; i < envelopes_red.Count; i++)
                {
                    intersector.AddRedEnvelope(i, envelopes_red[i]);
                }
                intersector.EndRedConstruction();
                intersector.StartBlueConstruction();
                for (int i_1 = 0; i_1 < envelopes_blue.Count; i_1++)
                {
                    intersector.AddBlueEnvelope(i_1, envelopes_blue[i_1]);
                }
                intersector.EndBlueConstruction();
                while (intersector.Next())
                {
                    eCount++;
                }
                NUnit.Framework.Assert.IsTrue(qCount == eCount);
            }
        }
示例#6
0
 internal PairwiseIntersectorImpl(com.epl.geometry.MultiPathImpl multi_path_impl_a, com.epl.geometry.MultiPathImpl multi_path_impl_b, double tolerance, bool b_paths)
 {
     m_multi_path_impl_a = multi_path_impl_a;
     m_multi_path_impl_b = multi_path_impl_b;
     m_b_paths           = b_paths;
     m_path_index        = -1;
     m_b_quad_tree       = false;
     com.epl.geometry.GeometryAccelerators geometry_accelerators_a = multi_path_impl_a._getAccelerators();
     if (geometry_accelerators_a != null)
     {
         com.epl.geometry.QuadTreeImpl qtree_a = (!b_paths ? geometry_accelerators_a.GetQuadTree() : geometry_accelerators_a.GetQuadTreeForPaths());
         if (qtree_a != null)
         {
             m_b_done          = false;
             m_tolerance       = tolerance;
             m_quad_tree       = qtree_a;
             m_qt_iter         = m_quad_tree.GetIterator();
             m_b_quad_tree     = true;
             m_b_swap_elements = true;
             m_function        = com.epl.geometry.PairwiseIntersectorImpl.State.nextPath;
             if (!b_paths)
             {
                 m_seg_iter = multi_path_impl_b.QuerySegmentIterator();
             }
             else
             {
                 m_path_index = multi_path_impl_b.GetPathCount();
             }
         }
     }
     // we will iterate backwards until we hit -1
     if (!m_b_quad_tree)
     {
         com.epl.geometry.GeometryAccelerators geometry_accelerators_b = multi_path_impl_b._getAccelerators();
         if (geometry_accelerators_b != null)
         {
             com.epl.geometry.QuadTreeImpl qtree_b = (!b_paths ? geometry_accelerators_b.GetQuadTree() : geometry_accelerators_b.GetQuadTreeForPaths());
             if (qtree_b != null)
             {
                 m_b_done          = false;
                 m_tolerance       = tolerance;
                 m_quad_tree       = qtree_b;
                 m_qt_iter         = m_quad_tree.GetIterator();
                 m_b_quad_tree     = true;
                 m_b_swap_elements = false;
                 m_function        = com.epl.geometry.PairwiseIntersectorImpl.State.nextPath;
                 if (!b_paths)
                 {
                     m_seg_iter = multi_path_impl_a.QuerySegmentIterator();
                 }
                 else
                 {
                     m_path_index = multi_path_impl_a.GetPathCount();
                 }
             }
         }
     }
     // we will iterate backwards until we hit -1
     if (!m_b_quad_tree)
     {
         if (!b_paths)
         {
             m_intersector = com.epl.geometry.InternalUtils.GetEnvelope2DIntersector(multi_path_impl_a, multi_path_impl_b, tolerance);
         }
         else
         {
             bool b_simple_a = multi_path_impl_a.GetIsSimple(0.0) >= 1;
             bool b_simple_b = multi_path_impl_b.GetIsSimple(0.0) >= 1;
             m_intersector = com.epl.geometry.InternalUtils.GetEnvelope2DIntersectorForParts(multi_path_impl_a, multi_path_impl_b, tolerance, b_simple_a, b_simple_b);
         }
     }
 }
 internal EndPointsComparer(com.epl.geometry.Envelope2DIntersectorImpl intersector, bool b_red)
 {
     // For user sort
     m_intersector = intersector;
     m_b_red       = b_red;
 }