docs: private static boolean polylineTouchesMultiPoint_(Polyline polyline_a,
  			MultiPoint multipoint_b, double tolerance,
  			ProgressTracker progress_tracker) {
  		// Quick rasterize test to see whether the the geometries are disjoint.
  		if (tryRasterizedContainsOrDisjoint_(polyline_a, multipoint_b,
  				tolerance, false) == Relation.disjoint) {
  			return false;
  		}
  
  		SegmentIteratorImpl segIterA = ((MultiPathImpl) polyline_a._getImpl())
  				.querySegmentIterator();
  
  		Envelope2D env_a = new Envelope2D();
  		Envelope2D env_b = new Envelope2D();
  		Envelope2D envInter = new Envelope2D();
  		polyline_a.queryEnvelope2D(env_a);
  		multipoint_b.queryEnvelope2D(env_b);
  		env_a.inflate(tolerance, tolerance);
  		env_b.inflate(tolerance, tolerance);
  		envInter.setCoords(env_a);
  		envInter.intersect(env_b);
  
  		QuadTreeImpl qtA = null;
  		QuadTreeImpl quadTreeA = null;
          QuadTreeImpl quadTreePathsA = null;
  
  		GeometryAccelerators accel = ((MultiPathImpl) (polyline_a._getImpl()))
  				._getAccelerators();
  
  		if (accel != null) {
  			quadTreeA = accel.getQuadTree();
              quadTreePathsA = accel.getQuadTreeForPaths();
  			if (quadTreeA == null) {
  				qtA = InternalUtils.buildQuadTree(
  						(MultiPathImpl) polyline_a._getImpl(), envInter);
  				quadTreeA = qtA;
  			}
  		} else {
  			qtA = InternalUtils.buildQuadTree(
  					(MultiPathImpl) polyline_a._getImpl(), envInter);
  			quadTreeA = qtA;
  		}
  
  		QuadTreeImpl.QuadTreeIteratorImpl qtIterA = quadTreeA.getIterator();
  
          QuadTreeImpl.QuadTreeIteratorImpl qtIterPathsA = null;
          if (quadTreePathsA != null)
              qtIterPathsA = quadTreePathsA.getIterator();
  
  		Point2D ptB = new Point2D(), closest = new Point2D();
  		boolean b_intersects = false;
  		double toleranceSq = tolerance * tolerance;
  
  		AttributeStreamOfInt8 intersects = new AttributeStreamOfInt8(
  				multipoint_b.getPointCount());
  		for (int i = 0; i < multipoint_b.getPointCount(); i++) {
  			intersects.write(i, (byte) 0);
  		}
  
  		for (int i = 0; i < multipoint_b.getPointCount(); i++) {
  			multipoint_b.getXY(i, ptB);
  
  			if (!envInter.contains(ptB)) {
  				continue;
  			}
  
  			env_b.setCoords(ptB.x, ptB.y, ptB.x, ptB.y);
  
              if (qtIterPathsA != null) {
                  qtIterPathsA.resetIterator(env_b, tolerance);
  
                  if (qtIterPathsA.next() == -1)
                      continue;
              }
  
  			qtIterA.resetIterator(env_b, tolerance);
  
  			for (int elementHandleA = qtIterA.next(); elementHandleA != -1; elementHandleA = qtIterA
  					.next()) {
  				int vertex_a = quadTreeA.getElement(elementHandleA);
  				segIterA.resetToVertex(vertex_a);
  
  				Segment segmentA = segIterA.nextSegment();
  				double t = segmentA.getClosestCoordinate(ptB, false);
  				segmentA.getCoord2D(t, closest);
  
  				if (Point2D.sqrDistance(ptB, closest) <= toleranceSq) {
  					intersects.write(i, (byte) 1);
  					b_intersects = true;
  					break;
  				}
  			}
  		}
  
  		if (!b_intersects) {
  			return false;
  		}
  
  		MultiPoint boundary_a = (MultiPoint) (polyline_a.getBoundary());
  		MultiPoint multipoint_b_inter = new MultiPoint();
  		Point2D pt = new Point2D();
  
  		for (int i = 0; i < multipoint_b.getPointCount(); i++) {
  			if (intersects.read(i) == 0) {
  				continue;
  			}
  
  			multipoint_b.getXY(i, pt);
  			multipoint_b_inter.add(pt.x, pt.y);
  		}
  
  		return multiPointContainsMultiPointBrute_(boundary_a,
  				multipoint_b_inter, tolerance);
  	}