docs: static boolean polygonContainsPolygon_(Polygon polygon_a, Polygon polygon_b, double tolerance, ProgressTracker progress_tracker)
      {
          assert(!polygon_a.isEmpty());
          assert(!polygon_b.isEmpty());
  
          RelationalOperationsMatrix relOps = new RelationalOperationsMatrix();
          relOps.resetMatrix_();
          relOps.setPredicates_("T*****F**");
          relOps.setAreaAreaPredicates_();
  
          Envelope2D env_a = new Envelope2D(), env_b = new Envelope2D();
          polygon_a.queryEnvelope2D(env_a);
          polygon_b.queryEnvelope2D(env_b);
  
          boolean bRelationKnown = false;
          boolean b_disjoint = RelationalOperations.envelopeDisjointEnvelope_(env_a, env_b, tolerance, progress_tracker);
  
          if (b_disjoint)
          {
              relOps.areaAreaDisjointPredicates_(polygon_a, polygon_b);
              bRelationKnown = true;
          }
  
          if (!bRelationKnown)
          {
              // Quick rasterize test to see whether the the geometries are disjoint, or if one is contained in the other.
              int relation = RelationalOperations.tryRasterizedContainsOrDisjoint_(polygon_a, polygon_b, tolerance, false);
  
              if (relation == RelationalOperations.Relation.disjoint)
              {
                  relOps.areaAreaDisjointPredicates_(polygon_a, polygon_b);
                  bRelationKnown = true;
              }
              else if (relation == RelationalOperations.Relation.contains)
              {
                  relOps.areaAreaContainsPredicates_(polygon_b);
                  bRelationKnown = true;
              }
              else if (relation == RelationalOperations.Relation.within)
              {
                  relOps.areaAreaWithinPredicates_(polygon_a);
                  bRelationKnown = true;
              }
          }
  
          if (bRelationKnown)
          {
              boolean bContains = relationCompare_(relOps.m_matrix, relOps.m_scl);
              return bContains;
          }
  
          EditShape edit_shape = new EditShape();
          int geom_a = edit_shape.addGeometry(polygon_a);
          int geom_b = edit_shape.addGeometry(polygon_b);
  
          CrackAndCluster.execute(edit_shape, tolerance, progress_tracker, false);
          Polyline boundary_b = (Polyline)edit_shape.getGeometry(geom_b).getBoundary();
          edit_shape.filterClosePoints(0, true, true);
          Simplificator.execute(edit_shape, geom_a, -1, false, progress_tracker);
  
          // Make sure Polygon A has exterior
          // If the simplified Polygon A does not have interior, then it cannot contain anything.
          if (edit_shape.getPointCount(geom_a) == 0)
              return false;
  
          Simplificator.execute(edit_shape, geom_b, -1, false, progress_tracker);
  
          relOps.setEditShape_(edit_shape, progress_tracker);
  
          // We see if the simplified Polygon A contains the simplified Polygon B.
  
          boolean b_empty = edit_shape.getPointCount(geom_b) == 0;
  
          if (!b_empty)
          {//geom_b has interior
              relOps.computeMatrixTopoGraphHalfEdges_(geom_a, geom_b);
              relOps.m_topo_graph.removeShape();
              boolean bContains = relationCompare_(relOps.m_matrix, relOps.m_scl);
  
              if (!bContains)
                  return bContains;
          }
  
          Polygon polygon_simple_a = (Polygon)edit_shape.getGeometry(geom_a);
          edit_shape = new EditShape();
          geom_a = edit_shape.addGeometry(polygon_simple_a);
          geom_b = edit_shape.addGeometry(boundary_b);
          relOps.setEditShape_(edit_shape, progress_tracker);
  
          // Check no interior lines of the boundary intersect the exterior
          relOps.m_predicate_count = 0;
          relOps.resetMatrix_();
          relOps.setPredicates_(b_empty ? "T*****F**" : "******F**");
          relOps.setAreaLinePredicates_();
  
          relOps.computeMatrixTopoGraphHalfEdges_(geom_a, geom_b);
          relOps.m_topo_graph.removeShape();
          boolean bContains = relationCompare_(relOps.m_matrix, relOps.m_scl);
          return bContains;
      }