public virtual void testEnvelopeGeometryEngine()
		{
			com.esri.core.geometry.Envelope e = new com.esri.core.geometry.Envelope();
			e.setCoords(-180.0, -90.0, 180.0, 90.0);
			string result = com.esri.core.geometry.GeometryEngine.geometryToGeoJson(e);
			NUnit.Framework.Assert.AreEqual("{\"bbox\":[-180.0,-90.0,180.0,90.0]}", result);
		}
		public virtual void testEnvelope()
		{
			com.esri.core.geometry.Envelope e = new com.esri.core.geometry.Envelope();
			e.setCoords(-180.0, -90.0, 180.0, 90.0);
			com.esri.core.geometry.OperatorExportToGeoJson exporter = (com.esri.core.geometry.OperatorExportToGeoJson
				)factory.getOperator(com.esri.core.geometry.Operator.Type.ExportToGeoJson);
			string result = exporter.execute(e);
			NUnit.Framework.Assert.AreEqual("{\"bbox\":[-180.0,-90.0,180.0,90.0]}", result);
		}
Exemple #3
0
		public virtual void testProximity2D_2()
		{
			com.esri.core.geometry.Point point1 = new com.esri.core.geometry.Point(3, 2);
			com.esri.core.geometry.Point point2 = new com.esri.core.geometry.Point(2, 4);
			com.esri.core.geometry.Envelope envelope = new com.esri.core.geometry.Envelope();
			envelope.setCoords(4, 3, 7, 6);
			com.esri.core.geometry.Polygon polygonToTest = new com.esri.core.geometry.Polygon
				();
			polygonToTest.addEnvelope(envelope, false);
			com.esri.core.geometry.Proximity2DResult prxResult1 = com.esri.core.geometry.GeometryEngine
				.getNearestVertex(envelope, point1);
			com.esri.core.geometry.Proximity2DResult prxResult2 = com.esri.core.geometry.GeometryEngine
				.getNearestVertex(polygonToTest, point1);
			com.esri.core.geometry.Proximity2DResult prxResult3 = com.esri.core.geometry.GeometryEngine
				.getNearestCoordinate(envelope, point2, false);
			com.esri.core.geometry.Proximity2DResult prxResult4 = com.esri.core.geometry.GeometryEngine
				.getNearestCoordinate(polygonToTest, point2, false);
			com.esri.core.geometry.Point result1 = prxResult1.getCoordinate();
			com.esri.core.geometry.Point result2 = prxResult2.getCoordinate();
			NUnit.Framework.Assert.IsTrue(result1.getX() == result2.getX());
			com.esri.core.geometry.Point result3 = prxResult3.getCoordinate();
			com.esri.core.geometry.Point result4 = prxResult4.getCoordinate();
			NUnit.Framework.Assert.IsTrue(result3.getX() == result4.getX());
		}
        /// <exception cref="org.codehaus.jackson.JsonParseException"/>
        /// <exception cref="System.IO.IOException"/>
        internal virtual bool testEnvelope()
        {
            bool bAnswer = true;

            com.esri.core.geometry.Envelope envelope = new com.esri.core.geometry.Envelope();
            envelope.setCoords(-109.55, 25.76, -86.39, 49.94);
            {
                org.codehaus.jackson.JsonParser envelopeWGS84Parser = factory.createJsonParser(com.esri.core.geometry.GeometryEngine
                                                                                               .geometryToJson(spatialReferenceWGS84, envelope));
                com.esri.core.geometry.MapGeometry envelopeWGS84MP = com.esri.core.geometry.GeometryEngine
                                                                     .jsonToGeometry(envelopeWGS84Parser);
                NUnit.Framework.Assert.IsTrue(envelope.isEmpty() == envelopeWGS84MP.getGeometry()
                                              .isEmpty());
                NUnit.Framework.Assert.IsTrue(envelope.getXMax() == ((com.esri.core.geometry.Envelope
                                                                      )envelopeWGS84MP.getGeometry()).getXMax());
                NUnit.Framework.Assert.IsTrue(envelope.getYMax() == ((com.esri.core.geometry.Envelope
                                                                      )envelopeWGS84MP.getGeometry()).getYMax());
                NUnit.Framework.Assert.IsTrue(envelope.getXMin() == ((com.esri.core.geometry.Envelope
                                                                      )envelopeWGS84MP.getGeometry()).getXMin());
                NUnit.Framework.Assert.IsTrue(envelope.getYMin() == ((com.esri.core.geometry.Envelope
                                                                      )envelopeWGS84MP.getGeometry()).getYMin());
                NUnit.Framework.Assert.IsTrue(spatialReferenceWGS84.getID() == envelopeWGS84MP.getSpatialReference
                                                  ().getID());
                if (!checkResultSpatialRef(envelopeWGS84MP, 4326, 0))
                {
                    bAnswer = false;
                }
            }
            {
                // export
                com.esri.core.geometry.Envelope e = new com.esri.core.geometry.Envelope();
                e.addAttribute(com.esri.core.geometry.VertexDescription.Semantics.Z);
                e.addAttribute(com.esri.core.geometry.VertexDescription.Semantics.M);
                string s = com.esri.core.geometry.GeometryEngine.geometryToJson(spatialReferenceWebMerc1
                                                                                , e);
                NUnit.Framework.Assert.IsTrue(s.Equals("{\"xmin\":null,\"ymin\":null,\"xmax\":null,\"ymax\":null,\"zmin\":null,\"zmax\":null,\"mmin\":null,\"mmax\":null,\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}"
                                                       ));
                e.setCoords(0, 1, 2, 3);
                com.esri.core.geometry.Envelope1D z = new com.esri.core.geometry.Envelope1D();
                com.esri.core.geometry.Envelope1D m = new com.esri.core.geometry.Envelope1D();
                z.setCoords(5, 7);
                m.setCoords(11, 13);
                e.setInterval(com.esri.core.geometry.VertexDescription.Semantics.Z, 0, z);
                e.setInterval(com.esri.core.geometry.VertexDescription.Semantics.M, 0, m);
                s = com.esri.core.geometry.GeometryEngine.geometryToJson(spatialReferenceWebMerc1
                                                                         , e);
                NUnit.Framework.Assert.IsTrue(s.Equals("{\"xmin\":0,\"ymin\":1,\"xmax\":2,\"ymax\":3,\"zmin\":5,\"zmax\":7,\"mmin\":11,\"mmax\":13,\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}"
                                                       ));
            }
            {
                // import
                string s = "{\"xmin\":0.0,\"ymin\":1.0,\"xmax\":2.0,\"ymax\":3.0,\"zmin\":5.0,\"zmax\":7.0,\"mmin\":11.0,\"mmax\":13.0,\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}";
                org.codehaus.jackson.JsonParser    parser  = factory.createJsonParser(s);
                com.esri.core.geometry.MapGeometry map_env = com.esri.core.geometry.GeometryEngine
                                                             .jsonToGeometry(parser);
                com.esri.core.geometry.Envelope env = (com.esri.core.geometry.Envelope)map_env.getGeometry
                                                          ();
                com.esri.core.geometry.Envelope1D z = env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                                        .Z, 0);
                com.esri.core.geometry.Envelope1D m = env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                                        .M, 0);
                NUnit.Framework.Assert.IsTrue(z.vmin == 5.0);
                NUnit.Framework.Assert.IsTrue(z.vmax == 7.0);
                NUnit.Framework.Assert.IsTrue(m.vmin == 11.0);
                NUnit.Framework.Assert.IsTrue(m.vmax == 13.0);
            }
            {
                string s = "{ \"zmin\" : 33, \"xmin\" : -109.55, \"zmax\" : 53, \"ymin\" : 25.76, \"xmax\" : -86.39, \"ymax\" : 49.94, \"mmax\" : 13}";
                org.codehaus.jackson.JsonParser    parser  = factory.createJsonParser(s);
                com.esri.core.geometry.MapGeometry map_env = com.esri.core.geometry.GeometryEngine
                                                             .jsonToGeometry(parser);
                com.esri.core.geometry.Envelope env = (com.esri.core.geometry.Envelope)map_env.getGeometry
                                                          ();
                com.esri.core.geometry.Envelope2D e = new com.esri.core.geometry.Envelope2D();
                env.queryEnvelope2D(e);
                NUnit.Framework.Assert.IsTrue(e.xmin == -109.55 && e.ymin == 25.76 && e.xmax == -
                                              86.39 && e.ymax == 49.94);
                com.esri.core.geometry.Envelope1D e1D;
                NUnit.Framework.Assert.IsTrue(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                               .Z));
                e1D = env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics.Z, 0);
                NUnit.Framework.Assert.IsTrue(e1D.vmin == 33 && e1D.vmax == 53);
                NUnit.Framework.Assert.IsTrue(!env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                                .M));
            }
            return(bAnswer);
        }
        public static void testRandom()
        {
            int passcount   = 10;
            int figureSize  = 100;
            int figureSize2 = 100;

            com.esri.core.geometry.Envelope extent1 = new com.esri.core.geometry.Envelope();
            com.esri.core.geometry.Envelope extent2 = new com.esri.core.geometry.Envelope();
            com.esri.core.geometry.Envelope extent3 = new com.esri.core.geometry.Envelope();
            com.esri.core.geometry.Envelope extent4 = new com.esri.core.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.esri.core.geometry.RandomCoordinateGenerator generator1 = new com.esri.core.geometry.RandomCoordinateGenerator
                                                                              (System.Math.max(figureSize, 10000), extent1, 0.001);
            com.esri.core.geometry.RandomCoordinateGenerator generator2 = new com.esri.core.geometry.RandomCoordinateGenerator
                                                                              (System.Math.max(figureSize, 10000), extent2, 0.001);
            com.esri.core.geometry.RandomCoordinateGenerator generator3 = new com.esri.core.geometry.RandomCoordinateGenerator
                                                                              (System.Math.max(figureSize, 10000), extent3, 0.001);
            com.esri.core.geometry.RandomCoordinateGenerator generator4 = new com.esri.core.geometry.RandomCoordinateGenerator
                                                                              (System.Math.max(figureSize, 10000), extent4, 0.001);
            java.util.Random random = new java.util.Random(1982);
            int rand_max            = 511;
            int qCount = 0;
            int eCount = 0;
            int bCount = 0;

            for (int c = 0; c < passcount; c++)
            {
                com.esri.core.geometry.Polygon polyRed  = new com.esri.core.geometry.Polygon();
                com.esri.core.geometry.Polygon polyBlue = new com.esri.core.geometry.Polygon();
                int r = figureSize;
                if (r < 3)
                {
                    continue;
                }
                com.esri.core.geometry.Point pt;
                for (int j = 0; j < r; j++)
                {
                    int  rand       = random.nextInt(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.nextInt(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.nextInt(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.nextInt(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.esri.core.geometry.Envelope2D env = new com.esri.core.geometry.Envelope2D();
                // Quad_tree
                com.esri.core.geometry.QuadTree quadTree = buildQuadTree(polyBlue);
                com.esri.core.geometry.QuadTree.QuadTreeIterator iterator = quadTree.getIterator(
                    );
                com.esri.core.geometry.SegmentIteratorImpl _segIterRed = ((com.esri.core.geometry.MultiPathImpl
                                                                           )polyRed._getImpl()).querySegmentIterator();
                while (_segIterRed.nextPath())
                {
                    while (_segIterRed.hasNextSegment())
                    {
                        com.esri.core.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.esri.core.geometry.Envelope2D> envelopes_red =
                    new System.Collections.Generic.List <com.esri.core.geometry.Envelope2D>();
                System.Collections.Generic.List <com.esri.core.geometry.Envelope2D> envelopes_blue
                    = new System.Collections.Generic.List <com.esri.core.geometry.Envelope2D>();
                com.esri.core.geometry.SegmentIterator segIterRed = polyRed.querySegmentIterator(
                    );
                while (segIterRed.nextPath())
                {
                    while (segIterRed.hasNextSegment())
                    {
                        com.esri.core.geometry.Segment segment = segIterRed.nextSegment();
                        env = new com.esri.core.geometry.Envelope2D();
                        segment.queryEnvelope2D(env);
                        envelopes_red.add(env);
                    }
                }
                com.esri.core.geometry.SegmentIterator segIterBlue = polyBlue.querySegmentIterator
                                                                         ();
                while (segIterBlue.nextPath())
                {
                    while (segIterBlue.hasNextSegment())
                    {
                        com.esri.core.geometry.Segment segment = segIterBlue.nextSegment();
                        env = new com.esri.core.geometry.Envelope2D();
                        segment.queryEnvelope2D(env);
                        envelopes_blue.add(env);
                    }
                }
                com.esri.core.geometry.Envelope2DIntersectorImpl intersector = new com.esri.core.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);
            }
        }
Exemple #6
0
 public virtual void testEnvelope()
 {
     com.esri.core.geometry.Envelope env = new com.esri.core.geometry.Envelope();
     env.setCoords(100, 200, 250, 300);
     NUnit.Framework.Assert.IsFalse(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M));
     env.addAttribute(com.esri.core.geometry.VertexDescription.Semantics.M);
     NUnit.Framework.Assert.IsTrue(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                    .M));
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M, 0).isEmpty());
     env.setInterval(com.esri.core.geometry.VertexDescription.Semantics.M, 0, 1, 2);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M, 0).vmin == 1);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M, 0).vmax == 2);
     NUnit.Framework.Assert.IsFalse(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z));
     env.addAttribute(com.esri.core.geometry.VertexDescription.Semantics.Z);
     NUnit.Framework.Assert.IsTrue(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                    .Z));
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmin == 0);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmax == 0);
     env.setInterval(com.esri.core.geometry.VertexDescription.Semantics.Z, 0, 3, 4);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmin == 3);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmax == 4);
     NUnit.Framework.Assert.IsFalse(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID));
     env.addAttribute(com.esri.core.geometry.VertexDescription.Semantics.ID);
     NUnit.Framework.Assert.IsTrue(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                    .ID));
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmin == 0);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmax == 0);
     env.setInterval(com.esri.core.geometry.VertexDescription.Semantics.ID, 0, 5, 6);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmin == 5);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmax == 6);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmin == 3);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmax == 4);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M, 0).vmin == 1);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M, 0).vmax == 2);
     env.dropAttribute(com.esri.core.geometry.VertexDescription.Semantics.M);
     NUnit.Framework.Assert.IsFalse(env.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                     .M));
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmin == 5);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .ID, 0).vmax == 6);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmin == 3);
     NUnit.Framework.Assert.IsTrue(env.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                     .Z, 0).vmax == 4);
     com.esri.core.geometry.Envelope env1 = new com.esri.core.geometry.Envelope();
     env.copyTo(env1);
     NUnit.Framework.Assert.IsFalse(env1.hasAttribute(com.esri.core.geometry.VertexDescription.Semantics
                                                      .M));
     NUnit.Framework.Assert.IsTrue(env1.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                      .ID, 0).vmin == 5);
     NUnit.Framework.Assert.IsTrue(env1.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                      .ID, 0).vmax == 6);
     NUnit.Framework.Assert.IsTrue(env1.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                      .Z, 0).vmin == 3);
     NUnit.Framework.Assert.IsTrue(env1.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                      .Z, 0).vmax == 4);
 }
        public static void testIntervalTreeRandomConstruction()
        {
            int pointcount = 0;
            int passcount  = 1000;
            int figureSize = 50;

            com.esri.core.geometry.Envelope env = new com.esri.core.geometry.Envelope();
            env.setCoords(-10000, -10000, 10000, 10000);
            com.esri.core.geometry.RandomCoordinateGenerator generator = new com.esri.core.geometry.RandomCoordinateGenerator
                                                                             (System.Math.max(figureSize, 10000), env, 0.001);
            java.util.Random random = new java.util.Random(2013);
            int rand_max            = 98765;

            System.Collections.Generic.List <com.esri.core.geometry.Envelope1D> intervals = new
                                                                                            System.Collections.Generic.List <com.esri.core.geometry.Envelope1D>();
            com.esri.core.geometry.AttributeStreamOfInt8 intervalsFound = new com.esri.core.geometry.AttributeStreamOfInt8
                                                                              (0);
            for (int i = 0; i < passcount; i++)
            {
                int r = figureSize;
                if (r < 3)
                {
                    continue;
                }
                com.esri.core.geometry.Polygon poly = new com.esri.core.geometry.Polygon();
                com.esri.core.geometry.Point   pt;
                for (int j = 0; j < r; j++)
                {
                    int  rand       = random.nextInt(rand_max);
                    bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
                    pt = generator.GetRandomCoord();
                    if (j == 0 || bRandomNew)
                    {
                        poly.startPath(pt);
                    }
                    else
                    {
                        poly.lineTo(pt);
                    }
                }
                {
                    intervals.clear();
                    com.esri.core.geometry.SegmentIterator seg_iter = poly.querySegmentIterator();
                    com.esri.core.geometry.Envelope1D      interval;
                    com.esri.core.geometry.Envelope1D      range = poly.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                                                      .POSITION, 0);
                    range.vmin -= 0.01;
                    range.vmax += 0.01;
                    while (seg_iter.nextPath())
                    {
                        while (seg_iter.hasNextSegment())
                        {
                            com.esri.core.geometry.Segment segment = seg_iter.nextSegment();
                            interval = segment.queryInterval(com.esri.core.geometry.VertexDescription.Semantics
                                                             .POSITION, 0);
                            intervals.add(interval);
                        }
                    }
                    intervalsFound.resize(intervals.Count, 0);
                    // Just test construction for assertions
                    com.esri.core.geometry.IntervalTreeImpl intervalTree = new com.esri.core.geometry.IntervalTreeImpl
                                                                               (true);
                    construct(intervalTree, intervals);
                    for (int j_1 = 0; j_1 < intervals.Count; j_1++)
                    {
                        intervalTree.insert(j_1);
                    }
                    com.esri.core.geometry.IntervalTreeImpl.IntervalTreeIteratorImpl iterator = intervalTree
                                                                                                .getIterator(range, 0.0);
                    int count = 0;
                    int handle;
                    while ((handle = iterator.next()) != -1)
                    {
                        count++;
                        intervalsFound.write(handle, unchecked ((byte)1));
                    }
                    NUnit.Framework.Assert.IsTrue(count == intervals.Count);
                    for (int j_2 = 0; j_2 < intervalsFound.size(); j_2++)
                    {
                        interval = intervals[j_2];
                        NUnit.Framework.Assert.IsTrue(intervalsFound.read(j_2) == 1);
                    }
                    for (int j_3 = 0; j_3 < intervals.Count >> 1; j_3++)
                    {
                        intervalTree.remove(j_3);
                    }
                    iterator.resetIterator(range, 0.0);
                    count = 0;
                    while ((handle = iterator.next()) != -1)
                    {
                        count++;
                        intervalsFound.write(handle, unchecked ((byte)1));
                    }
                    NUnit.Framework.Assert.IsTrue(count == intervals.Count - (intervals.Count >> 1));
                    for (int j_4 = (intervals.Count >> 1); j_4 < intervals.Count; j_4++)
                    {
                        intervalTree.remove(j_4);
                    }
                }
            }
        }
 public static void testPointTypes()
 {
     com.esri.core.geometry.OperatorFactoryLocal engine = com.esri.core.geometry.OperatorFactoryLocal
                                                          .getInstance();
     com.esri.core.geometry.OperatorDifference difference = (com.esri.core.geometry.OperatorDifference
                                                             )engine.getOperator(com.esri.core.geometry.Operator.Type.Difference);
     com.esri.core.geometry.OperatorSymmetricDifference sym_difference = (com.esri.core.geometry.OperatorSymmetricDifference
                                                                          )engine.getOperator(com.esri.core.geometry.Operator.Type.SymmetricDifference);
     {
         // point/point
         com.esri.core.geometry.Point point_1 = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         point_1.setXY(0, 0);
         point_2.setXY(0.000000009, 0.000000009);
         com.esri.core.geometry.Point differenced = (com.esri.core.geometry.Point)(difference
                                                                                   .execute(point_1, point_2, com.esri.core.geometry.SpatialReference.create(4326),
                                                                                            null));
         NUnit.Framework.Assert.IsTrue(differenced.isEmpty());
         com.esri.core.geometry.MultiPoint sym_differenced = (com.esri.core.geometry.MultiPoint
                                                              )(sym_difference.execute(point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                       .create(4326), null));
         NUnit.Framework.Assert.IsTrue(sym_differenced.isEmpty());
     }
     {
         // point/point
         com.esri.core.geometry.Point point_1 = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         point_1.setXY(0, 0);
         point_2.setXY(0.000000009, 0.0);
         com.esri.core.geometry.Point differenced = (com.esri.core.geometry.Point)(difference
                                                                                   .execute(point_1, point_2, com.esri.core.geometry.SpatialReference.create(4326),
                                                                                            null));
         NUnit.Framework.Assert.IsTrue(differenced.isEmpty());
         com.esri.core.geometry.MultiPoint sym_differenced = (com.esri.core.geometry.MultiPoint
                                                              )(sym_difference.execute(point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                       .create(4326), null));
         NUnit.Framework.Assert.IsTrue(sym_differenced.isEmpty());
     }
     {
         // point/point
         com.esri.core.geometry.Point point_1 = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         point_1.setXY(0, 0);
         point_2.setXY(0.00000002, 0.00000002);
         com.esri.core.geometry.Point differenced_1 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_1, point_2, com.esri.core.geometry.SpatialReference.create(4326),
                                                                                              null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         com.esri.core.geometry.Point differenced_2 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_2, point_1, com.esri.core.geometry.SpatialReference.create(4326),
                                                                                              null));
         NUnit.Framework.Assert.IsTrue(!differenced_2.isEmpty());
         com.esri.core.geometry.MultiPoint sym_differenced = (com.esri.core.geometry.MultiPoint
                                                              )(sym_difference.execute(point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                       .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!sym_differenced.isEmpty());
         NUnit.Framework.Assert.IsTrue(sym_differenced.getXY(0).x == 0 && sym_differenced.
                                       getXY(0).y == 0);
         NUnit.Framework.Assert.IsTrue(sym_differenced.getXY(1).x == 0.00000002 && sym_differenced
                                       .getXY(1).y == 0.00000002);
     }
     {
         // multi_point/point
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         multi_point_1.add(0, 0);
         multi_point_1.add(1, 1);
         point_2.setXY(0.000000009, 0.000000009);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1.getPointCount() == 1);
         NUnit.Framework.Assert.IsTrue(differenced_1.getXY(0).x == 1 && differenced_1.getXY
                                           (0).y == 1);
         com.esri.core.geometry.Point differenced_2 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_2, multi_point_1, com.esri.core.geometry.SpatialReference.create(
                                                                                                  4326), null));
         NUnit.Framework.Assert.IsTrue(differenced_2.isEmpty());
     }
     {
         // multi_point/point
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         multi_point_1.add(0, 0);
         multi_point_1.add(1, 1);
         point_2.setXY(0.000000009, 0.0);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1.getXY(0).x == 1.0 && differenced_1.getXY
                                           (0).y == 1.0);
         com.esri.core.geometry.Point differenced_2 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_2, multi_point_1, com.esri.core.geometry.SpatialReference.create(
                                                                                                  4326), null));
         NUnit.Framework.Assert.IsTrue(differenced_2.isEmpty());
         com.esri.core.geometry.MultiPoint sym_differenced = (com.esri.core.geometry.MultiPoint
                                                              )(sym_difference.execute(multi_point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                       .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!sym_differenced.isEmpty());
         NUnit.Framework.Assert.IsTrue(sym_differenced.getPointCount() == 1);
         NUnit.Framework.Assert.IsTrue(sym_differenced.getXY(0).x == 1 && sym_differenced.
                                       getXY(0).y == 1);
     }
     {
         // multi_point/point
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Point point_2 = new com.esri.core.geometry.Point();
         multi_point_1.add(0, 0);
         multi_point_1.add(0, 0);
         point_2.setXY(0.000000009, 0.0);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
         com.esri.core.geometry.MultiPoint sym_differenced = (com.esri.core.geometry.MultiPoint
                                                              )(sym_difference.execute(multi_point_1, point_2, com.esri.core.geometry.SpatialReference
                                                                                       .create(4326), null));
         NUnit.Framework.Assert.IsTrue(sym_differenced.isEmpty());
     }
     {
         // multi_point/polygon
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Polygon polygon_2 = new com.esri.core.geometry.Polygon();
         multi_point_1.add(0, 0);
         multi_point_1.add(0, 0);
         multi_point_1.add(2, 2);
         polygon_2.startPath(-1, -1);
         polygon_2.lineTo(-1, 1);
         polygon_2.lineTo(1, 1);
         polygon_2.lineTo(1, -1);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, polygon_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1.getPointCount() == 1);
         NUnit.Framework.Assert.IsTrue(differenced_1.getXY(0).x == 2 && differenced_1.getXY
                                           (0).y == 2);
     }
     {
         // multi_point/polygon
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Polygon polygon_2 = new com.esri.core.geometry.Polygon();
         multi_point_1.add(0, 0);
         multi_point_1.add(0, 0);
         multi_point_1.add(1, 1);
         polygon_2.startPath(-1, -1);
         polygon_2.lineTo(-1, 1);
         polygon_2.lineTo(1, 1);
         polygon_2.lineTo(1, -1);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, polygon_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
     }
     {
         // multi_point/envelope
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Envelope envelope_2 = new com.esri.core.geometry.Envelope(
             );
         multi_point_1.add(-2, 0);
         multi_point_1.add(0, 2);
         multi_point_1.add(2, 0);
         multi_point_1.add(0, -2);
         envelope_2.setCoords(-1, -1, 1, 1);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, envelope_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty() && differenced_1 == multi_point_1
                                       );
     }
     {
         // multi_point/polygon
         com.esri.core.geometry.MultiPoint multi_point_1 = new com.esri.core.geometry.MultiPoint
                                                               ();
         com.esri.core.geometry.Polygon polygon_2 = new com.esri.core.geometry.Polygon();
         multi_point_1.add(2, 2);
         multi_point_1.add(2, 2);
         multi_point_1.add(-2, -2);
         polygon_2.startPath(-1, -1);
         polygon_2.lineTo(-1, 1);
         polygon_2.lineTo(1, 1);
         polygon_2.lineTo(1, -1);
         com.esri.core.geometry.MultiPoint differenced_1 = (com.esri.core.geometry.MultiPoint
                                                            )(difference.execute(multi_point_1, polygon_2, com.esri.core.geometry.SpatialReference
                                                                                 .create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty() && differenced_1 == multi_point_1
                                       );
     }
     {
         // point/polygon
         com.esri.core.geometry.Point   point_1   = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Polygon polygon_2 = new com.esri.core.geometry.Polygon();
         point_1.setXY(0, 0);
         polygon_2.startPath(-1, -1);
         polygon_2.lineTo(-1, 1);
         polygon_2.lineTo(1, 1);
         polygon_2.lineTo(1, -1);
         com.esri.core.geometry.Point differenced_1 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_1, polygon_2, com.esri.core.geometry.SpatialReference.create(4326
                                                                                                                                                                 ), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
         polygon_2.setEmpty();
         polygon_2.startPath(1, 1);
         polygon_2.lineTo(1, 2);
         polygon_2.lineTo(2, 2);
         polygon_2.lineTo(2, 1);
         differenced_1 = (com.esri.core.geometry.Point)(difference.execute(point_1, polygon_2
                                                                           , com.esri.core.geometry.SpatialReference.create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
     }
     {
         // point/polygon
         com.esri.core.geometry.Point   point_1   = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Polygon polygon_2 = new com.esri.core.geometry.Polygon();
         point_1.setXY(0, 0);
         polygon_2.startPath(1, 0);
         polygon_2.lineTo(0, 1);
         polygon_2.lineTo(1, 1);
         com.esri.core.geometry.Point differenced_1 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_1, polygon_2, com.esri.core.geometry.SpatialReference.create(4326
                                                                                                                                                                 ), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
         point_1.setEmpty();
         point_1.setXY(0.5, 0.5);
         polygon_2.setEmpty();
         polygon_2.startPath(1, 0);
         polygon_2.lineTo(0, 1);
         polygon_2.lineTo(1, 1);
         differenced_1 = (com.esri.core.geometry.Point)(difference.execute(point_1, polygon_2
                                                                           , com.esri.core.geometry.SpatialReference.create(4326), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
     }
     {
         // point/envelope
         com.esri.core.geometry.Point    point_1    = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Envelope envelope_2 = new com.esri.core.geometry.Envelope(
             );
         point_1.setXY(0, 0);
         envelope_2.setCoords(-1, -1, 1, 1);
         com.esri.core.geometry.Point differenced_1 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_1, envelope_2, com.esri.core.geometry.SpatialReference.create(4326
                                                                                                                                                                  ), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
         envelope_2.setEmpty();
         envelope_2.setCoords(1, 1, 2, 2);
         differenced_1 = (com.esri.core.geometry.Point)(difference.execute(point_1, envelope_2
                                                                           , com.esri.core.geometry.SpatialReference.create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
     }
     {
         // point/polyline
         com.esri.core.geometry.Point    point_1    = new com.esri.core.geometry.Point();
         com.esri.core.geometry.Polyline polyline_2 = new com.esri.core.geometry.Polyline(
             );
         point_1.setXY(0, 0);
         polyline_2.startPath(-1, 0);
         polyline_2.lineTo(1, 0);
         com.esri.core.geometry.Point differenced_1 = (com.esri.core.geometry.Point)(difference
                                                                                     .execute(point_1, polyline_2, com.esri.core.geometry.SpatialReference.create(4326
                                                                                                                                                                  ), null));
         NUnit.Framework.Assert.IsTrue(differenced_1.isEmpty());
         polyline_2.setEmpty();
         polyline_2.startPath(1, 0);
         polyline_2.lineTo(2, 0);
         differenced_1 = (com.esri.core.geometry.Point)(difference.execute(point_1, polyline_2
                                                                           , com.esri.core.geometry.SpatialReference.create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
         polyline_2.setEmpty();
         polyline_2.startPath(-1, -1);
         polyline_2.lineTo(-1, 1);
         polyline_2.lineTo(1, 1);
         polyline_2.lineTo(1, -1);
         differenced_1 = (com.esri.core.geometry.Point)(difference.execute(point_1, polyline_2
                                                                           , com.esri.core.geometry.SpatialReference.create(4326), null));
         NUnit.Framework.Assert.IsTrue(!differenced_1.isEmpty());
         NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
     }
 }