Java Code Examples for org.apache.commons.math3.geometry.partitioning.Region.Location#OUTSIDE

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // retrieve the underlying lines
    Line line1 = (Line) getHyperplane();
    Line line2 = (Line) subLine.getHyperplane();

    // compute the intersection on infinite line
    Vector2D v2D = line1.intersection(line2);
    if (v2D == null) {
        return null;
    }

    // check location of point with respect to first sub-line
    Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // retrieve the underlying lines
    Line line1 = (Line) getHyperplane();
    Line line2 = (Line) subLine.getHyperplane();

    // compute the intersection on infinite line
    Vector2D v2D = line1.intersection(line2);
    if (v2D == null) {
        return null;
    }

    // check location of point with respect to first sub-line
    Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace((Point<Euclidean2D>) v2D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace((Point<Euclidean2D>) v2D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector3D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // compute the intersection on infinite line
    Vector3D v1D = line.intersection(subLine.line);
    if (v1D == null) {
        return null;
    }

    // check location of point with respect to first sub-line
    Location loc1 = remainingRegion.checkPoint((Point<Euclidean1D>) line.toSubSpace((Point<Euclidean3D>) v1D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.remainingRegion.checkPoint((Point<Euclidean1D>) subLine.line.toSubSpace((Point<Euclidean3D>) v1D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v1D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v1D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // retrieve the underlying lines
    Line line1 = (Line) getHyperplane();
    Line line2 = (Line) subLine.getHyperplane();

    // compute the intersection on infinite line
    Vector2D v2D = line1.intersection(line2);

    // check location of point with respect to first sub-line
    Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
    }

}
 

/**
 * Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line) intersection}
 * method in the {@link Line Line} class, but in addition to compute the point
 * along infinite lines, it also checks the point lies on both sub-line ranges.
 * </p>
 * 
 * @param subLine          other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 *                         instance (i.e. they are closed sets) and may be
 *                         returned, otherwise endpoints are considered to not
 *                         belong to instance (i.e. they are open sets) and
 *                         intersection occurring on endpoints lead to null
 *                         being returned
 * @return the intersection point if there is one, null if the sub-lines don't
 *         intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

	// retrieve the underlying lines
	Line line1 = (Line) getHyperplane();
	Line line2 = (Line) subLine.getHyperplane();

	// compute the intersection on infinite line
	Vector2D v2D = line1.intersection(line2);
	if (v2D == null) {//Math-4
		return null;
	}

	// check location of point with respect to first sub-line
	Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

	// check location of point with respect to second sub-line
	Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

	if (includeEndPoints) {
		return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
	} else {
		return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
	}

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // retrieve the underlying lines
    Line line1 = (Line) getHyperplane();
    Line line2 = (Line) subLine.getHyperplane();

    // compute the intersection on infinite line
    Vector2D v2D = line1.intersection(line2);

    // check location of point with respect to first sub-line
    Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // retrieve the underlying lines
    Line line1 = (Line) getHyperplane();
    Line line2 = (Line) subLine.getHyperplane();

    // compute the intersection on infinite line
    Vector2D v2D = line1.intersection(line2);

    // check location of point with respect to first sub-line
    Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector3D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // compute the intersection on infinite line
    Vector3D v1D = line.intersection(subLine.line);

    // check location of point with respect to first sub-line
    Location loc1 = remainingRegion.checkPoint(line.toSubSpace(v1D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.remainingRegion.checkPoint(subLine.line.toSubSpace(v1D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v1D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v1D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector3D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // compute the intersection on infinite line
    Vector3D v1D = line.intersection(subLine.line);
    if (v1D == null) {
        return null;
    }

    // check location of point with respect to first sub-line
    Location loc1 = remainingRegion.checkPoint((Point<Euclidean1D>) line.toSubSpace((Point<Euclidean3D>) v1D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.remainingRegion.checkPoint((Point<Euclidean1D>) subLine.line.toSubSpace((Point<Euclidean3D>) v1D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v1D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v1D : null;
    }

}
 

/** Get the intersection of the instance and another sub-line.
 * <p>
 * This method is related to the {@link Line#intersection(Line)
 * intersection} method in the {@link Line Line} class, but in addition
 * to compute the point along infinite lines, it also checks the point
 * lies on both sub-line ranges.
 * </p>
 * @param subLine other sub-line which may intersect instance
 * @param includeEndPoints if true, endpoints are considered to belong to
 * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
 * are considered to not belong to instance (i.e. they are open sets) and intersection
 * occurring on endpoints lead to null being returned
 * @return the intersection point if there is one, null if the sub-lines don't intersect
 */
public Vector3D intersection(final SubLine subLine, final boolean includeEndPoints) {

    // compute the intersection on infinite line
    Vector3D v1D = line.intersection(subLine.line);
    if (v1D == null) {
        return null;
    }

    // check location of point with respect to first sub-line
    Location loc1 = remainingRegion.checkPoint(line.toSubSpace(v1D));

    // check location of point with respect to second sub-line
    Location loc2 = subLine.remainingRegion.checkPoint(subLine.line.toSubSpace(v1D));

    if (includeEndPoints) {
        return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v1D : null;
    } else {
        return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v1D : null;
    }

}
 

/** Check a point with respect to the interval.
 * @param point point to check
 * @param tolerance tolerance below which points are considered to
 * belong to the boundary
 * @return a code representing the point status: either {@link
 * Location#INSIDE}, {@link Location#OUTSIDE} or {@link Location#BOUNDARY}
 * @since 3.1
 */
public Location checkPoint(final double point, final double tolerance) {
    if (point < lower - tolerance || point > upper + tolerance) {
        return Location.OUTSIDE;
    } else if (point > lower + tolerance && point < upper - tolerance) {
        return Location.INSIDE;
    } else {
        return Location.BOUNDARY;
    }
}
 

/** Check a point with respect to the interval.
 * @param point point to check
 * @param tolerance tolerance below which points are considered to
 * belong to the boundary
 * @return a code representing the point status: either {@link
 * Location#INSIDE}, {@link Location#OUTSIDE} or {@link Location#BOUNDARY}
 * @since 3.1
 */
public Location checkPoint(final double point, final double tolerance) {
    if (point < lower - tolerance || point > upper + tolerance) {
        return Location.OUTSIDE;
    } else if (point > lower + tolerance && point < upper - tolerance) {
        return Location.INSIDE;
    } else {
        return Location.BOUNDARY;
    }
}
 

/** Check a point with respect to the interval.
 * @param point point to check
 * @param tolerance tolerance below which points are considered to
 * belong to the boundary
 * @return a code representing the point status: either {@link
 * Location#INSIDE}, {@link Location#OUTSIDE} or {@link Location#BOUNDARY}
 * @since 3.1
 */
public Location checkPoint(final double point, final double tolerance) {
    if (point < lower - tolerance || point > upper + tolerance) {
        return Location.OUTSIDE;
    } else if (point > lower + tolerance && point < upper - tolerance) {
        return Location.INSIDE;
    } else {
        return Location.BOUNDARY;
    }
}
 

/** {@inheritDoc} */
public BSPTree<S> fixNode(final BSPTree<S> node) {
    // get a representative point in the degenerate cell
    final BSPTree<S> cell = node.pruneAroundConvexCell(Boolean.TRUE, Boolean.FALSE, null);
    final Region<S> r = region1.buildNew(cell);
    final Point<S> p = r.getBarycenter();
    return new BSPTree<S>(region1.checkPoint(p) == Location.INSIDE &&
                          region2.checkPoint(p) == Location.OUTSIDE);
}
 

/** Check if a projected point lies on a boundary part.
 * @param point projected point to check
 * @param hyperplane hyperplane into which the point was projected
 * @param part boundary part
 * @return true if point lies on the boundary part
 */
private boolean belongsToPart(final Point<S> point, final Hyperplane<S> hyperplane,
                              final Region<T> part) {

    // there is a non-null sub-space, we can dive into smaller dimensions
    @SuppressWarnings("unchecked")
    final Embedding<S, T> embedding = (Embedding<S, T>) hyperplane;
    return part.checkPoint(embedding.toSubSpace(point)) != Location.OUTSIDE;

}
 

/**
 * Discretizes the particular provided value. Discretization in this case means
 * to replace the original value by a categorical value. The categorical value
 * is simply the index of the interval the value was assigned to.
 *
 * @param value
 *            The (numeric) value to be discretized
 * @param policy
 *            The policy that has to be used for discretization
 * @return
 */
protected int discretize(final double value, final AttributeDiscretizationPolicy policy) {
	List<Interval> intervals = policy.getIntervals();
	// Find the interval to which the value belongs
	for (Interval i : intervals) {
		if (i.checkPoint(value, 0) != Location.OUTSIDE) {
			return intervals.indexOf(i);
		}
	}

	throw new IllegalStateException(String.format("Policy does not cover value %f", value));
}
 

/** Check if a projected point lies on a boundary part.
 * @param point projected point to check
 * @param hyperplane hyperplane into which the point was projected
 * @param part boundary part
 * @return true if point lies on the boundary part
 */
private boolean belongsToPart(final Point<S> point, final Hyperplane<S> hyperplane,
                              final Region<T> part) {

    // there is a non-null sub-space, we can dive into smaller dimensions
    @SuppressWarnings("unchecked")
    final Embedding<S, T> embedding = (Embedding<S, T>) hyperplane;
    return part.checkPoint(embedding.toSubSpace(point)) != Location.OUTSIDE;

}
 

/** {@inheritDoc} */
public BSPTree<S> fixNode(final BSPTree<S> node) {
    // get a representative point in the degenerate cell
    final BSPTree<S> cell = node.pruneAroundConvexCell(Boolean.TRUE, Boolean.FALSE, null);
    final Region<S> r = region1.buildNew(cell);
    final Point<S> p = r.getBarycenter();
    return new BSPTree<S>(region1.checkPoint(p) == Location.INSIDE &&
                          region2.checkPoint(p) == Location.OUTSIDE);
}
 

/** Check a point with respect to the arc.
 * @param point point to check
 * @return a code representing the point status: either {@link
 * Location#INSIDE}, {@link Location#OUTSIDE} or {@link Location#BOUNDARY}
 */
public Location checkPoint(final double point) {
    final double normalizedPoint = MathUtils.normalizeAngle(point, middle);
    if (normalizedPoint < lower - tolerance || normalizedPoint > upper + tolerance) {
        return Location.OUTSIDE;
    } else if (normalizedPoint > lower + tolerance && normalizedPoint < upper - tolerance) {
        return Location.INSIDE;
    } else {
        return (getSize() >= MathUtils.TWO_PI - tolerance) ? Location.INSIDE : Location.BOUNDARY;
    }
}
 

/** Get the intersection of the instance and another sub-line.
     * <p>
     * This method is related to the {@link Line#intersection(Line)
     * intersection} method in the {@link Line Line} class, but in addition
     * to compute the point along infinite lines, it also checks the point
     * lies on both sub-line ranges.
     * </p>
     * @param subLine other sub-line which may intersect instance
     * @param includeEndPoints if true, endpoints are considered to belong to
     * instance (i.e. they are closed sets) and may be returned, otherwise endpoints
     * are considered to not belong to instance (i.e. they are open sets) and intersection
     * occurring on endpoints lead to null being returned
     * @return the intersection point if there is one, null if the sub-lines don't intersect
     */
    public Vector2D intersection(final SubLine subLine, final boolean includeEndPoints) {

        // retrieve the underlying lines
        Line line1 = (Line) getHyperplane();
        Line line2 = (Line) subLine.getHyperplane();

        // compute the intersection on infinite line
        Vector2D v2D = line1.intersection(line2);
//        FIX
//        if (v2D == null) {
//            return null;
//        }

        // check location of point with respect to first sub-line
        Location loc1 = getRemainingRegion().checkPoint(line1.toSubSpace(v2D));

        // check location of point with respect to second sub-line
        Location loc2 = subLine.getRemainingRegion().checkPoint(line2.toSubSpace(v2D));

        if (includeEndPoints) {
            return ((loc1 != Location.OUTSIDE) && (loc2 != Location.OUTSIDE)) ? v2D : null;
        } else {
            return ((loc1 == Location.INSIDE) && (loc2 == Location.INSIDE)) ? v2D : null;
        }

    }