docs: static boolean isPathConvex(MultiPath multi_path, int path_index, ProgressTracker progress_tracker) {
  		MultiPathImpl mimpl = (MultiPathImpl) multi_path._getImpl();
  		int path_start = mimpl.getPathStart(path_index);
  		int path_end = mimpl.getPathEnd(path_index);
  
  		boolean bxyclosed = !mimpl.isClosedPath(path_index) && mimpl.isClosedPathInXYPlane(path_index);
  
  		AttributeStreamOfDbl position = (AttributeStreamOfDbl) (mimpl.getAttributeStreamRef(VertexDescription.Semantics.POSITION));
  		int position_start = 2 * path_start;
  		int position_end = 2 * path_end;
  
  		if (bxyclosed)
  			position_end -= 2;
  
  		if (position_end - position_start < 6)
  			return true;
  
  		// This matches the logic for case 1 of the tree hull algorithm. The idea is inductive. We assume we have a convex hull pt_0,...,pt_m, and we see if
  		// a new point (pt_pivot) is among the transitive tournament for pt_0, knowing that pt_pivot comes after pt_m.
  
  		// We check three conditions:
  		// 1) pt_m->pt_pivot->pt_0 is clockwise (closure across the boundary is convex)
  		// 2) pt_1->pt_pivot->pt_0 is clockwise (the first step forward is convex)  (pt_1 is the next point after pt_0)
  		// 3) pt_m->pt_pivot->pt_m_prev is clockwise (the first step backwards is convex)  (pt_m_prev is the previous point before pt_m)
  
  		// If all three of the above conditions are clockwise, then pt_pivot is among the transitive tournament for pt_0, and therefore the polygon pt_0, ..., pt_m, pt_pivot is convex.
  
  		Point2D pt_0 = new Point2D(), pt_m = new Point2D(), pt_pivot = new Point2D();
  		position.read(position_start, pt_0);
  		position.read(position_start + 2, pt_m);
  		position.read(position_start + 4, pt_pivot);
  
  		// Initial inductive step
  		ECoordinate det_ec = determinant_(pt_m, pt_pivot, pt_0);
  
  		if (det_ec.isFuzzyZero() || !isClockwise_(det_ec.value()))
  			return false;
  
  		Point2D pt_1 = new Point2D(pt_m.x, pt_m.y);
  		Point2D pt_m_prev = new Point2D();
  
  		// Assume that pt_0,...,pt_m is convex. Check if the next point, pt_pivot, maintains the convex invariant.
  		for (int i = position_start + 6; i < position_end; i += 2) {
  			pt_m_prev.setCoords(pt_m);
  			pt_m.setCoords(pt_pivot);
  			position.read(i, pt_pivot);
  
  			det_ec = determinant_(pt_m, pt_pivot, pt_0);
  
  			if (det_ec.isFuzzyZero() || !isClockwise_(det_ec.value()))
  				return false;
  
  			det_ec = determinant_(pt_1, pt_pivot, pt_0);
  
  			if (det_ec.isFuzzyZero() || !isClockwise_(det_ec.value()))
  				return false;
  
  			det_ec = determinant_(pt_m, pt_pivot, pt_m_prev);
  
  			if (det_ec.isFuzzyZero() || !isClockwise_(det_ec.value()))
  				return false;
  		}
  
  		return true;
  	}