Class RelationalOperations


  • class RelationalOperations
    extends java.lang.Object
    • Constructor Detail

      • RelationalOperations

        private RelationalOperations()
    • Method Detail

      • polygonRelatePolygon_

        private static boolean polygonRelatePolygon_​(Polygon polygon_a,
                                                     Polygon polygon_b,
                                                     double tolerance,
                                                     int relation,
                                                     ProgressTracker progress_tracker)
      • polygonRelatePolyline_

        private static boolean polygonRelatePolyline_​(Polygon polygon_a,
                                                      Polyline polyline_b,
                                                      double tolerance,
                                                      int relation,
                                                      ProgressTracker progress_tracker)
      • polygonRelatePoint_

        private static boolean polygonRelatePoint_​(Polygon polygon_a,
                                                   Point point_b,
                                                   double tolerance,
                                                   int relation,
                                                   ProgressTracker progress_tracker)
      • polygonRelateMultiPoint_

        private static boolean polygonRelateMultiPoint_​(Polygon polygon_a,
                                                        MultiPoint multipoint_b,
                                                        double tolerance,
                                                        int relation,
                                                        ProgressTracker progress_tracker)
      • polygonRelateEnvelope_

        private static boolean polygonRelateEnvelope_​(Polygon polygon_a,
                                                      Envelope envelope_b,
                                                      double tolerance,
                                                      int relation,
                                                      ProgressTracker progress_tracker)
      • polylineRelatePolyline_

        private static boolean polylineRelatePolyline_​(Polyline polyline_a,
                                                       Polyline polyline_b,
                                                       double tolerance,
                                                       int relation,
                                                       ProgressTracker progress_tracker)
      • polylineRelatePoint_

        private static boolean polylineRelatePoint_​(Polyline polyline_a,
                                                    Point point_b,
                                                    double tolerance,
                                                    int relation,
                                                    ProgressTracker progress_tracker)
      • polylineRelateMultiPoint_

        private static boolean polylineRelateMultiPoint_​(Polyline polyline_a,
                                                         MultiPoint multipoint_b,
                                                         double tolerance,
                                                         int relation,
                                                         ProgressTracker progress_tracker)
      • polylineRelateEnvelope_

        private static boolean polylineRelateEnvelope_​(Polyline polyline_a,
                                                       Envelope envelope_b,
                                                       double tolerance,
                                                       int relation,
                                                       ProgressTracker progress_tracker)
      • multiPointRelateMultiPoint_

        private static boolean multiPointRelateMultiPoint_​(MultiPoint multipoint_a,
                                                           MultiPoint multipoint_b,
                                                           double tolerance,
                                                           int relation,
                                                           ProgressTracker progress_tracker)
      • multiPointRelatePoint_

        private static boolean multiPointRelatePoint_​(MultiPoint multipoint_a,
                                                      Point point_b,
                                                      double tolerance,
                                                      int relation,
                                                      ProgressTracker progress_tracker)
      • multiPointRelateEnvelope_

        private static boolean multiPointRelateEnvelope_​(MultiPoint multipoint_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         int relation,
                                                         ProgressTracker progress_tracker)
      • polygonEqualsPolygon_

        private static boolean polygonEqualsPolygon_​(Polygon polygon_a,
                                                     Polygon polygon_b,
                                                     double tolerance,
                                                     ProgressTracker progress_tracker)
      • polygonDisjointPolygon_

        private static boolean polygonDisjointPolygon_​(Polygon polygon_a,
                                                       Polygon polygon_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonTouchesPolygon_

        private static boolean polygonTouchesPolygon_​(Polygon polygon_a,
                                                      Polygon polygon_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polygonOverlapsPolygon_

        private static boolean polygonOverlapsPolygon_​(Polygon polygon_a,
                                                       Polygon polygon_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonContainsPolygon_

        private static boolean polygonContainsPolygon_​(Polygon polygon_a,
                                                       Polygon polygon_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonDisjointPolyline_

        private static boolean polygonDisjointPolyline_​(Polygon polygon_a,
                                                        Polyline polyline_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polygonTouchesPolyline_

        private static boolean polygonTouchesPolyline_​(Polygon polygon_a,
                                                       Polyline polyline_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonCrossesPolyline_

        private static boolean polygonCrossesPolyline_​(Polygon polygon_a,
                                                       Polyline polyline_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonContainsPolyline_

        private static boolean polygonContainsPolyline_​(Polygon polygon_a,
                                                        Polyline polyline_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polygonDisjointPoint_

        private static boolean polygonDisjointPoint_​(Polygon polygon_a,
                                                     Point point_b,
                                                     double tolerance,
                                                     ProgressTracker progress_tracker)
      • polygonTouchesPoint_

        private static boolean polygonTouchesPoint_​(Polygon polygon_a,
                                                    Point point_b,
                                                    double tolerance,
                                                    ProgressTracker progress_tracker)
      • polygonContainsPoint_

        private static boolean polygonContainsPoint_​(Polygon polygon_a,
                                                     Point point_b,
                                                     double tolerance,
                                                     ProgressTracker progress_tracker)
      • polygonDisjointMultiPoint_

        private static boolean polygonDisjointMultiPoint_​(Polygon polygon_a,
                                                          MultiPoint multipoint_b,
                                                          double tolerance,
                                                          boolean bIncludeBoundaryA,
                                                          ProgressTracker progress_tracker)
      • polygonTouchesMultiPoint_

        private static boolean polygonTouchesMultiPoint_​(Polygon polygon_a,
                                                         MultiPoint multipoint_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polygonCrossesMultiPoint_

        private static boolean polygonCrossesMultiPoint_​(Polygon polygon_a,
                                                         MultiPoint multipoint_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polygonContainsMultiPoint_

        private static boolean polygonContainsMultiPoint_​(Polygon polygon_a,
                                                          MultiPoint multipoint_b,
                                                          double tolerance,
                                                          ProgressTracker progress_tracker)
      • polygonEqualsEnvelope_

        private static boolean polygonEqualsEnvelope_​(Polygon polygon_a,
                                                      Envelope envelope_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polygonDisjointEnvelope_

        private static boolean polygonDisjointEnvelope_​(Polygon polygon_a,
                                                        Envelope envelope_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polygonTouchesEnvelope_

        private static boolean polygonTouchesEnvelope_​(Polygon polygon_a,
                                                       Envelope envelope_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polygonOverlapsEnvelope_

        private static boolean polygonOverlapsEnvelope_​(Polygon polygon_a,
                                                        Envelope envelope_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polygonWithinEnvelope_

        private static boolean polygonWithinEnvelope_​(Polygon polygon_a,
                                                      Envelope envelope_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polygonContainsEnvelope_

        private static boolean polygonContainsEnvelope_​(Polygon polygon_a,
                                                        Envelope envelope_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polygonCrossesEnvelope_

        private static boolean polygonCrossesEnvelope_​(Polygon polygon_a,
                                                       Envelope envelope_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polylineEqualsPolyline_

        private static boolean polylineEqualsPolyline_​(Polyline polyline_a,
                                                       Polyline polyline_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polylineDisjointPolyline_

        private static boolean polylineDisjointPolyline_​(Polyline polyline_a,
                                                         Polyline polyline_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineTouchesPolyline_

        private static boolean polylineTouchesPolyline_​(Polyline polyline_a,
                                                        Polyline polyline_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polylineCrossesPolyline_

        private static boolean polylineCrossesPolyline_​(Polyline polyline_a,
                                                        Polyline polyline_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polylineOverlapsPolyline_

        private static boolean polylineOverlapsPolyline_​(Polyline polyline_a,
                                                         Polyline polyline_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineContainsPolyline_

        private static boolean polylineContainsPolyline_​(Polyline polyline_a,
                                                         Polyline polyline_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineDisjointPoint_

        private static boolean polylineDisjointPoint_​(Polyline polyline_a,
                                                      Point point_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polylineTouchesPoint_

        private static boolean polylineTouchesPoint_​(Polyline polyline_a,
                                                     Point point_b,
                                                     double tolerance,
                                                     ProgressTracker progress_tracker)
      • polylineContainsPoint_

        private static boolean polylineContainsPoint_​(Polyline polyline_a,
                                                      Point point_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polylineDisjointMultiPoint_

        private static boolean polylineDisjointMultiPoint_​(Polyline polyline_a,
                                                           MultiPoint multipoint_b,
                                                           double tolerance,
                                                           ProgressTracker progress_tracker)
      • polylineTouchesMultiPoint_

        private static boolean polylineTouchesMultiPoint_​(Polyline polyline_a,
                                                          MultiPoint multipoint_b,
                                                          double tolerance,
                                                          ProgressTracker progress_tracker)
      • polylineCrossesMultiPoint_

        private static boolean polylineCrossesMultiPoint_​(Polyline polyline_a,
                                                          MultiPoint multipoint_b,
                                                          double tolerance,
                                                          ProgressTracker progress_tracker)
      • polylineContainsMultiPoint_

        private static boolean polylineContainsMultiPoint_​(Polyline polyline_a,
                                                           MultiPoint multipoint_b,
                                                           double tolerance,
                                                           ProgressTracker progress_tracker)
      • polylineEqualsEnvelope_

        private static boolean polylineEqualsEnvelope_​(Polyline polyline_a,
                                                       Envelope envelope_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polylineDisjointEnvelope_

        private static boolean polylineDisjointEnvelope_​(Polyline polyline_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineTouchesEnvelope_

        private static boolean polylineTouchesEnvelope_​(Polyline polyline_a,
                                                        Envelope envelope_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • polylineOverlapsEnvelope_

        private static boolean polylineOverlapsEnvelope_​(Polyline polyline_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineWithinEnvelope_

        private static boolean polylineWithinEnvelope_​(Polyline polyline_a,
                                                       Envelope envelope_b,
                                                       double tolerance,
                                                       ProgressTracker progress_tracker)
      • polylineContainsEnvelope_

        private static boolean polylineContainsEnvelope_​(Polyline polyline_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • polylineCrossesEnvelope_

        private static boolean polylineCrossesEnvelope_​(Polyline polyline_a,
                                                        Envelope envelope_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • multiPointEqualsMultiPoint_

        private static boolean multiPointEqualsMultiPoint_​(MultiPoint multipoint_a,
                                                           MultiPoint multipoint_b,
                                                           double tolerance,
                                                           ProgressTracker progress_tracker)
      • multiPointDisjointMultiPoint_

        private static boolean multiPointDisjointMultiPoint_​(MultiPoint multipoint_a,
                                                             MultiPoint multipoint_b,
                                                             double tolerance,
                                                             ProgressTracker progress_tracker)
      • multiPointOverlapsMultiPoint_

        private static boolean multiPointOverlapsMultiPoint_​(MultiPoint multipoint_a,
                                                             MultiPoint multipoint_b,
                                                             double tolerance,
                                                             ProgressTracker progress_tracker)
      • multiPointContainsMultiPoint_

        private static boolean multiPointContainsMultiPoint_​(MultiPoint multipoint_a,
                                                             MultiPoint multipoint_b,
                                                             double tolerance,
                                                             ProgressTracker progress_tracker)
      • multiPointContainsMultiPointBrute_

        private static boolean multiPointContainsMultiPointBrute_​(MultiPoint multipoint_a,
                                                                  MultiPoint multipoint_b,
                                                                  double tolerance)
      • multiPointEqualsPoint_

        static boolean multiPointEqualsPoint_​(MultiPoint multipoint_a,
                                              Point point_b,
                                              double tolerance,
                                              ProgressTracker progress_tracker)
      • multiPointDisjointPoint_

        private static boolean multiPointDisjointPoint_​(MultiPoint multipoint_a,
                                                        Point point_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • multiPointWithinPoint_

        private static boolean multiPointWithinPoint_​(MultiPoint multipoint_a,
                                                      Point point_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • multiPointContainsPoint_

        private static boolean multiPointContainsPoint_​(MultiPoint multipoint_a,
                                                        Point point_b,
                                                        double tolerance,
                                                        ProgressTracker progress_tracker)
      • multiPointEqualsEnvelope_

        private static boolean multiPointEqualsEnvelope_​(MultiPoint multipoint_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • multiPointDisjointEnvelope_

        private static boolean multiPointDisjointEnvelope_​(MultiPoint multipoint_a,
                                                           Envelope envelope_b,
                                                           double tolerance,
                                                           ProgressTracker progress_tracker)
      • multiPointTouchesEnvelope_

        private static boolean multiPointTouchesEnvelope_​(MultiPoint multipoint_a,
                                                          Envelope envelope_b,
                                                          double tolerance,
                                                          ProgressTracker progress_tracker)
      • multiPointWithinEnvelope_

        private static boolean multiPointWithinEnvelope_​(MultiPoint multipoint_a,
                                                         Envelope envelope_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • multiPointContainsEnvelope_

        private static boolean multiPointContainsEnvelope_​(MultiPoint multipoint_a,
                                                           Envelope envelope_b,
                                                           double tolerance,
                                                           ProgressTracker progress_tracker)
      • multiPointCrossesEnvelope_

        static boolean multiPointCrossesEnvelope_​(MultiPoint multipoint_a,
                                                  Envelope envelope_b,
                                                  double tolerance,
                                                  ProgressTracker progress_tracker)
      • pointEqualsPoint_

        private static boolean pointEqualsPoint_​(Point2D pt_a,
                                                 Point2D pt_b,
                                                 double tolerance,
                                                 ProgressTracker progress_tracker)
      • pointDisjointPoint_

        private static boolean pointDisjointPoint_​(Point2D pt_a,
                                                   Point2D pt_b,
                                                   double tolerance,
                                                   ProgressTracker progress_tracker)
      • pointContainsPoint_

        private static boolean pointContainsPoint_​(Point2D pt_a,
                                                   Point2D pt_b,
                                                   double tolerance,
                                                   ProgressTracker progress_tracker)
      • pointTouchesEnvelope_

        private static boolean pointTouchesEnvelope_​(Point2D pt_a,
                                                     Envelope2D env_b,
                                                     double tolerance,
                                                     ProgressTracker progress_tracker)
      • pointContainsEnvelope_

        private static boolean pointContainsEnvelope_​(Point2D pt_a,
                                                      Envelope2D env_b,
                                                      double tolerance,
                                                      ProgressTracker progress_tracker)
      • polygonDisjointMultiPath_

        private static boolean polygonDisjointMultiPath_​(Polygon polygon_a,
                                                         MultiPath multipath_b,
                                                         double tolerance,
                                                         ProgressTracker progress_tracker)
      • envelopeInfContainsEnvelope_

        private static boolean envelopeInfContainsEnvelope_​(Envelope2D env_a,
                                                            Envelope2D env_b,
                                                            double tolerance)
      • interiorEnvExteriorEnv_

        private static boolean interiorEnvExteriorEnv_​(Envelope2D env_a,
                                                       Envelope2D env_b,
                                                       double tolerance)
      • multiPathExactlyEqualsMultiPath_

        private static boolean multiPathExactlyEqualsMultiPath_​(MultiPath multipathA,
                                                                MultiPath multipathB,
                                                                double tolerance,
                                                                ProgressTracker progress_tracker)
      • multiPointExactlyEqualsMultiPoint_

        private static boolean multiPointExactlyEqualsMultiPoint_​(MultiPoint multipoint_a,
                                                                  MultiPoint multipoint_b,
                                                                  double tolerance,
                                                                  ProgressTracker progress_tracker)
      • multiPointCoverageMultiPoint_

        private static boolean multiPointCoverageMultiPoint_​(MultiPoint _multipointA,
                                                             MultiPoint _multipointB,
                                                             double tolerance,
                                                             boolean bPerformWithin,
                                                             boolean bPerformEquals,
                                                             boolean bPerformOverlaps,
                                                             ProgressTracker progress_tracker)
      • multiPointIntersectsMultiPoint_

        private static boolean multiPointIntersectsMultiPoint_​(MultiPoint _multipointA,
                                                               MultiPoint _multipointB,
                                                               double tolerance,
                                                               ProgressTracker progress_tracker)
      • linearPathEqualsLinearPath_

        private static boolean linearPathEqualsLinearPath_​(MultiPath multipathA,
                                                           MultiPath multipathB,
                                                           double tolerance,
                                                           boolean bEnforceOrientation)
      • linearPathWithinLinearPath_

        private static boolean linearPathWithinLinearPath_​(MultiPath multipathA,
                                                           MultiPath multipathB,
                                                           double tolerance,
                                                           boolean bEnforceOrientation)
      • linearPathOverlapsLinearPath_

        private static boolean linearPathOverlapsLinearPath_​(MultiPath multipathA,
                                                             MultiPath multipathB,
                                                             double tolerance)
      • linearPathIntersectsLinearPathMaxDim_

        static int linearPathIntersectsLinearPathMaxDim_​(MultiPath _multipathA,
                                                         MultiPath _multipathB,
                                                         double tolerance,
                                                         AttributeStreamOfDbl intersections)
      • linearPathIntersectsLinearPath_

        private static boolean linearPathIntersectsLinearPath_​(MultiPath multipathA,
                                                               MultiPath multipathB,
                                                               double tolerance)
      • linearPathIntersectsMultiPoint_

        private static boolean linearPathIntersectsMultiPoint_​(MultiPath multipathA,
                                                               MultiPoint multipoint_b,
                                                               double tolerance,
                                                               boolean b_intersects_all)
      • linearPathIntersectsPoint_

        static boolean linearPathIntersectsPoint_​(MultiPath multipathA,
                                                  Point2D ptB,
                                                  double tolerance)
      • linearPathContainsPoint_

        private static boolean linearPathContainsPoint_​(MultiPath multipathA,
                                                        Point2D pt_b,
                                                        double tolerance)
      • linearPathTouchesPointImpl_

        private static boolean linearPathTouchesPointImpl_​(MultiPath multipathA,
                                                           Point2D ptB,
                                                           double tolerance)
      • linearPathIntersectsEnvelope_

        private static boolean linearPathIntersectsEnvelope_​(MultiPath multipath_a,
                                                             Envelope2D env_b,
                                                             double tolerance,
                                                             ProgressTracker progress_tracker)
      • tryRasterizedContainsOrDisjoint_

        static int tryRasterizedContainsOrDisjoint_​(Geometry geom_a,
                                                    Geometry geom_b,
                                                    double tolerance,
                                                    boolean bExtraTestForIntersects)
      • polygonTouchesPolygonImpl_

        private static boolean polygonTouchesPolygonImpl_​(Polygon polygon_a,
                                                          Polygon polygon_b,
                                                          double tolerance,
                                                          ProgressTracker progressTracker)
      • polygonOverlapsPolygonImpl_

        private static boolean polygonOverlapsPolygonImpl_​(Polygon polygon_a,
                                                           Polygon polygon_b,
                                                           double tolerance,
                                                           ProgressTracker progressTracker)
      • polygonContainsPolygonImpl_

        private static boolean polygonContainsPolygonImpl_​(Polygon polygon_a,
                                                           Polygon polygon_b,
                                                           double tolerance,
                                                           ProgressTracker progressTracker)
      • polygonContainsMultiPath_

        private static boolean polygonContainsMultiPath_​(Polygon polygon_a,
                                                         MultiPath multi_path_b,
                                                         double tolerance,
                                                         boolean[] b_result_known,
                                                         ProgressTracker progress_tracker)
      • polygonTouchesPolylineImpl_

        private static boolean polygonTouchesPolylineImpl_​(Polygon polygon_a,
                                                           Polyline polyline_b,
                                                           double tolerance,
                                                           ProgressTracker progressTracker)
      • polygonCrossesPolylineImpl_

        private static boolean polygonCrossesPolylineImpl_​(Polygon polygon_a,
                                                           Polyline polyline_b,
                                                           double tolerance,
                                                           ProgressTracker progressTracker)
      • polygonContainsPolylineImpl_

        private static boolean polygonContainsPolylineImpl_​(Polygon polygon_a,
                                                            Polyline polyline_b,
                                                            double tolerance,
                                                            ProgressTracker progress_tracker)
      • polygonContainsPointImpl_

        private static boolean polygonContainsPointImpl_​(Polygon polygon_a,
                                                         Point2D pt_b,
                                                         double tolerance,
                                                         ProgressTracker progressTracker)
      • polygonTouchesPointImpl_

        private static boolean polygonTouchesPointImpl_​(Polygon polygon_a,
                                                        Point2D pt_b,
                                                        double tolerance,
                                                        ProgressTracker progressTracker)
      • multiPointDisjointPointImpl_

        static boolean multiPointDisjointPointImpl_​(MultiPoint multipoint_a,
                                                    Point2D pt_b,
                                                    double tolerance,
                                                    ProgressTracker progressTracker)
      • compareOverlapEvents_

        int compareOverlapEvents_​(int o_1,
                                  int o_2)