// GEOMTHROW(internal_error);
        // unreachable in java
        // return null;
        private com.epl.geometry.Geometry DensifySegment(com.epl.geometry.Segment geom)
        {
            double length = geom.CalculateLength2D();

            if (length <= m_maxLength)
            {
                return((com.epl.geometry.Geometry)geom);
            }
            com.epl.geometry.Polyline polyline = new com.epl.geometry.Polyline(geom.GetDescription());
            polyline.AddSegment(geom, true);
            return(DensifyMultiPath((com.epl.geometry.MultiPath)polyline));
        }
        public static int QuickTest2D(com.epl.geometry.Geometry geomA, com.epl.geometry.Geometry geomB, double tolerance, int testType)
        {
            if (geomB.IsEmpty() || geomA.IsEmpty())
            {
                return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
            }
            int geomAtype = geomA.GetType().Value();
            int geomBtype = geomB.GetType().Value();

            // We do not support segments directly for now. Convert to Polyline
            com.epl.geometry.Polyline autoPolyA;
            if (com.epl.geometry.Geometry.IsSegment(geomAtype))
            {
                autoPolyA = new com.epl.geometry.Polyline(geomA.GetDescription());
                geomA     = (com.epl.geometry.Geometry)autoPolyA;
                autoPolyA.AddSegment((com.epl.geometry.Segment)geomA, true);
            }
            com.epl.geometry.Polyline autoPolyB;
            if (com.epl.geometry.Geometry.IsSegment(geomBtype))
            {
                autoPolyB = new com.epl.geometry.Polyline(geomB.GetDescription());
                geomB     = (com.epl.geometry.Geometry)autoPolyB;
                autoPolyB.AddSegment((com.epl.geometry.Segment)geomB, true);
            }
            switch (geomAtype)
            {
            case com.epl.geometry.Geometry.GeometryType.Point:
            {
                switch (geomBtype)
                {
                case com.epl.geometry.Geometry.GeometryType.Point:
                {
                    // Now process GeometryxGeometry case by case
                    return(QuickTest2DPointPoint((com.epl.geometry.Point)geomA, (com.epl.geometry.Point)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Envelope:
                {
                    return(ReverseResult(QuickTest2DEnvelopePoint((com.epl.geometry.Envelope)geomB, (com.epl.geometry.Point)geomA, tolerance)));
                }

                case com.epl.geometry.Geometry.GeometryType.MultiPoint:
                {
                    return(ReverseResult(QuickTest2DMultiPointPoint((com.epl.geometry.MultiPoint)geomB, (com.epl.geometry.Point)geomA, tolerance)));
                }

                case com.epl.geometry.Geometry.GeometryType.Polyline:
                {
                    return(ReverseResult(QuickTest2DPolylinePoint((com.epl.geometry.Polyline)geomB, (com.epl.geometry.Point)geomA, tolerance, testType)));
                }

                case com.epl.geometry.Geometry.GeometryType.Polygon:
                {
                    return(ReverseResult(QuickTest2DPolygonPoint((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Point)geomA, tolerance)));
                }
                }
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }

            case com.epl.geometry.Geometry.GeometryType.Envelope:
            {
                switch (geomBtype)
                {
                case com.epl.geometry.Geometry.GeometryType.Point:
                {
                    // GEOMTHROW(internal_error);//what
                    // else?
                    return(QuickTest2DEnvelopePoint((com.epl.geometry.Envelope)geomA, (com.epl.geometry.Point)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Envelope:
                {
                    return(QuickTest2DEnvelopeEnvelope((com.epl.geometry.Envelope)geomA, (com.epl.geometry.Envelope)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.MultiPoint:
                {
                    return(ReverseResult(QuickTest2DMultiPointEnvelope((com.epl.geometry.MultiPoint)geomB, (com.epl.geometry.Envelope)geomA, tolerance, testType)));
                }

                case com.epl.geometry.Geometry.GeometryType.Polyline:
                {
                    return(ReverseResult(QuickTest2DPolylineEnvelope((com.epl.geometry.Polyline)geomB, (com.epl.geometry.Envelope)geomA, tolerance)));
                }

                case com.epl.geometry.Geometry.GeometryType.Polygon:
                {
                    return(ReverseResult(QuickTest2DPolygonEnvelope((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Envelope)geomA, tolerance)));
                }
                }
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }

            case com.epl.geometry.Geometry.GeometryType.MultiPoint:
            {
                switch (geomBtype)
                {
                case com.epl.geometry.Geometry.GeometryType.Point:
                {
                    // GEOMTHROW(internal_error);//what
                    // else?
                    return(QuickTest2DMultiPointPoint((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.Point)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Envelope:
                {
                    return(QuickTest2DMultiPointEnvelope((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.Envelope)geomB, tolerance, testType));
                }

                case com.epl.geometry.Geometry.GeometryType.MultiPoint:
                {
                    return(QuickTest2DMultiPointMultiPoint((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance, testType));
                }

                case com.epl.geometry.Geometry.GeometryType.Polyline:
                {
                    return(ReverseResult(QuickTest2DPolylineMultiPoint((com.epl.geometry.Polyline)geomB, (com.epl.geometry.MultiPoint)geomA, tolerance)));
                }

                case com.epl.geometry.Geometry.GeometryType.Polygon:
                {
                    return(ReverseResult(QuickTest2DPolygonMultiPoint((com.epl.geometry.Polygon)geomB, (com.epl.geometry.MultiPoint)geomA, tolerance)));
                }
                }
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }

            case com.epl.geometry.Geometry.GeometryType.Polyline:
            {
                switch (geomBtype)
                {
                case com.epl.geometry.Geometry.GeometryType.Point:
                {
                    // GEOMTHROW(internal_error);//what
                    // else?
                    return(QuickTest2DPolylinePoint((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Point)geomB, tolerance, testType));
                }

                case com.epl.geometry.Geometry.GeometryType.Envelope:
                {
                    return(QuickTest2DPolylineEnvelope((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Envelope)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.MultiPoint:
                {
                    return(QuickTest2DPolylineMultiPoint((com.epl.geometry.Polyline)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Polyline:
                {
                    return(QuickTest2DPolylinePolyline((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Polyline)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Polygon:
                {
                    return(ReverseResult(QuickTest2DPolygonPolyline((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Polyline)geomA, tolerance)));
                }
                }
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }

            case com.epl.geometry.Geometry.GeometryType.Polygon:
            {
                switch (geomBtype)
                {
                case com.epl.geometry.Geometry.GeometryType.Point:
                {
                    // GEOMTHROW(internal_error);//what
                    // else?
                    return(QuickTest2DPolygonPoint((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Point)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Envelope:
                {
                    return(QuickTest2DPolygonEnvelope((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Envelope)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.MultiPoint:
                {
                    return(QuickTest2DPolygonMultiPoint((com.epl.geometry.Polygon)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Polyline:
                {
                    return(QuickTest2DPolygonPolyline((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Polyline)geomB, tolerance));
                }

                case com.epl.geometry.Geometry.GeometryType.Polygon:
                {
                    return(QuickTest2DPolygonPolygon((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Polygon)geomB, tolerance));
                }
                }
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }

            default:
            {
                // GEOMTHROW(internal_error);//what
                // else?
                throw com.epl.geometry.GeometryException.GeometryInternalError();
            }
            }
        }