org.apache.lucene.spatial3d.geom.StandardXYZSolid Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of lucene-spatial3d Show documentation
Show all versions of lucene-spatial3d Show documentation
Lucene Spatial shapes implemented using 3D planar geometry
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.lucene.spatial3d.geom;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 3D rectangle, bounded on six sides by X,Y,Z limits
*
* @lucene.internal
*/
class StandardXYZSolid extends BaseXYZSolid {
/** Min-X */
protected final double minX;
/** Max-X */
protected final double maxX;
/** Min-Y */
protected final double minY;
/** Max-Y */
protected final double maxY;
/** Min-Z */
protected final double minZ;
/** Max-Z */
protected final double maxZ;
/** Whole world? */
protected final boolean isWholeWorld;
/** Min-X plane */
protected final SidedPlane minXPlane;
/** Max-X plane */
protected final SidedPlane maxXPlane;
/** Min-Y plane */
protected final SidedPlane minYPlane;
/** Max-Y plane */
protected final SidedPlane maxYPlane;
/** Min-Z plane */
protected final SidedPlane minZPlane;
/** Max-Z plane */
protected final SidedPlane maxZPlane;
/** true if minXPlane intersects globe */
protected final boolean minXPlaneIntersects;
/** true if maxXPlane intersects globe */
protected final boolean maxXPlaneIntersects;
/** true if minYPlane intersects globe */
protected final boolean minYPlaneIntersects;
/** true if maxYPlane intersects globe */
protected final boolean maxYPlaneIntersects;
/** true if minZPlane intersects globe */
protected final boolean minZPlaneIntersects;
/** true if maxZPlane intersects globe */
protected final boolean maxZPlaneIntersects;
/**
* These are the edge points of the shape, which are defined to be at least one point on each
* surface area boundary. In the case of a solid, this includes points which represent the
* intersection of XYZ bounding planes and the planet, as well as points representing the
* intersection of single bounding planes with the planet itself.
*/
protected final GeoPoint[] edgePoints;
/** Notable points for minXPlane */
protected final GeoPoint[] notableMinXPoints;
/** Notable points for maxXPlane */
protected final GeoPoint[] notableMaxXPoints;
/** Notable points for minYPlane */
protected final GeoPoint[] notableMinYPoints;
/** Notable points for maxYPlane */
protected final GeoPoint[] notableMaxYPoints;
/** Notable points for minZPlane */
protected final GeoPoint[] notableMinZPoints;
/** Notable points for maxZPlane */
protected final GeoPoint[] notableMaxZPoints;
/**
* Sole constructor
*
* @param planetModel is the planet model.
* @param minX is the minimum X value.
* @param maxX is the maximum X value.
* @param minY is the minimum Y value.
* @param maxY is the maximum Y value.
* @param minZ is the minimum Z value.
* @param maxZ is the maximum Z value.
*/
public StandardXYZSolid(
final PlanetModel planetModel,
final double minX,
final double maxX,
final double minY,
final double maxY,
final double minZ,
final double maxZ) {
super(planetModel);
// Argument checking
if (maxX - minX < Vector.MINIMUM_RESOLUTION)
throw new IllegalArgumentException("X values in wrong order or identical");
if (maxY - minY < Vector.MINIMUM_RESOLUTION)
throw new IllegalArgumentException("Y values in wrong order or identical");
if (maxZ - minZ < Vector.MINIMUM_RESOLUTION)
throw new IllegalArgumentException("Z values in wrong order or identical");
this.minX = minX;
this.maxX = maxX;
this.minY = minY;
this.maxY = maxY;
this.minZ = minZ;
this.maxZ = maxZ;
final double worldMinX = planetModel.getMinimumXValue();
final double worldMaxX = planetModel.getMaximumXValue();
final double worldMinY = planetModel.getMinimumYValue();
final double worldMaxY = planetModel.getMaximumYValue();
final double worldMinZ = planetModel.getMinimumZValue();
final double worldMaxZ = planetModel.getMaximumZValue();
// We must distinguish between the case where the solid represents the entire world,
// and when the solid has no overlap with any part of the surface. In both cases,
// there will be no edgepoints.
isWholeWorld =
(minX - worldMinX < -Vector.MINIMUM_RESOLUTION)
&& (maxX - worldMaxX > Vector.MINIMUM_RESOLUTION)
&& (minY - worldMinY < -Vector.MINIMUM_RESOLUTION)
&& (maxY - worldMaxY > Vector.MINIMUM_RESOLUTION)
&& (minZ - worldMinZ < -Vector.MINIMUM_RESOLUTION)
&& (maxZ - worldMaxZ > Vector.MINIMUM_RESOLUTION);
if (isWholeWorld) {
minXPlane = null;
maxXPlane = null;
minYPlane = null;
maxYPlane = null;
minZPlane = null;
maxZPlane = null;
minXPlaneIntersects = false;
maxXPlaneIntersects = false;
minYPlaneIntersects = false;
maxYPlaneIntersects = false;
minZPlaneIntersects = false;
maxZPlaneIntersects = false;
notableMinXPoints = null;
notableMaxXPoints = null;
notableMinYPoints = null;
notableMaxYPoints = null;
notableMinZPoints = null;
notableMaxZPoints = null;
edgePoints = null;
} else {
// Construct the planes
minXPlane = new SidedPlane(maxX, 0.0, 0.0, xUnitVector, -minX);
maxXPlane = new SidedPlane(minX, 0.0, 0.0, xUnitVector, -maxX);
minYPlane = new SidedPlane(0.0, maxY, 0.0, yUnitVector, -minY);
maxYPlane = new SidedPlane(0.0, minY, 0.0, yUnitVector, -maxY);
minZPlane = new SidedPlane(0.0, 0.0, maxZ, zUnitVector, -minZ);
maxZPlane = new SidedPlane(0.0, 0.0, minZ, zUnitVector, -maxZ);
// We need at least one point on the planet surface for each manifestation of the shape.
// There can be up to 2 (on opposite sides of the world). But we have to go through
// 12 combinations of adjacent planes in order to find out if any have 2 intersection
// solution. Typically, this requires 12 square root operations.
final GeoPoint[] minXminY =
minXPlane.findIntersections(
planetModel, minYPlane, maxXPlane, maxYPlane, minZPlane, maxZPlane);
final GeoPoint[] minXmaxY =
minXPlane.findIntersections(
planetModel, maxYPlane, maxXPlane, minYPlane, minZPlane, maxZPlane);
final GeoPoint[] minXminZ =
minXPlane.findIntersections(
planetModel, minZPlane, maxXPlane, maxZPlane, minYPlane, maxYPlane);
final GeoPoint[] minXmaxZ =
minXPlane.findIntersections(
planetModel, maxZPlane, maxXPlane, minZPlane, minYPlane, maxYPlane);
final GeoPoint[] maxXminY =
maxXPlane.findIntersections(
planetModel, minYPlane, minXPlane, maxYPlane, minZPlane, maxZPlane);
final GeoPoint[] maxXmaxY =
maxXPlane.findIntersections(
planetModel, maxYPlane, minXPlane, minYPlane, minZPlane, maxZPlane);
final GeoPoint[] maxXminZ =
maxXPlane.findIntersections(
planetModel, minZPlane, minXPlane, maxZPlane, minYPlane, maxYPlane);
final GeoPoint[] maxXmaxZ =
maxXPlane.findIntersections(
planetModel, maxZPlane, minXPlane, minZPlane, minYPlane, maxYPlane);
final GeoPoint[] minYminZ =
minYPlane.findIntersections(
planetModel, minZPlane, maxYPlane, maxZPlane, minXPlane, maxXPlane);
final GeoPoint[] minYmaxZ =
minYPlane.findIntersections(
planetModel, maxZPlane, maxYPlane, minZPlane, minXPlane, maxXPlane);
final GeoPoint[] maxYminZ =
maxYPlane.findIntersections(
planetModel, minZPlane, minYPlane, maxZPlane, minXPlane, maxXPlane);
final GeoPoint[] maxYmaxZ =
maxYPlane.findIntersections(
planetModel, maxZPlane, minYPlane, minZPlane, minXPlane, maxXPlane);
notableMinXPoints = glueTogether(minXminY, minXmaxY, minXminZ, minXmaxZ);
notableMaxXPoints = glueTogether(maxXminY, maxXmaxY, maxXminZ, maxXmaxZ);
notableMinYPoints = glueTogether(minXminY, maxXminY, minYminZ, minYmaxZ);
notableMaxYPoints = glueTogether(minXmaxY, maxXmaxY, maxYminZ, maxYmaxZ);
notableMinZPoints = glueTogether(minXminZ, maxXminZ, minYminZ, maxYminZ);
notableMaxZPoints = glueTogether(minXmaxZ, maxXmaxZ, minYmaxZ, maxYmaxZ);
// System.err.println(
// " notableMinXPoints="+Arrays.asList(notableMinXPoints)+"
// notableMaxXPoints="+Arrays.asList(notableMaxXPoints)+
// " notableMinYPoints="+Arrays.asList(notableMinYPoints)+"
// notableMaxYPoints="+Arrays.asList(notableMaxYPoints)+
// " notableMinZPoints="+Arrays.asList(notableMinZPoints)+"
// notableMaxZPoints="+Arrays.asList(notableMaxZPoints));
// Now, compute the edge points.
// This is the trickiest part of setting up an XYZSolid. We've computed intersections
// already, so we'll start there.
// There can be a number of shapes, each of which needs an edgepoint. Each side by itself
// might contribute an edgepoint, for instance, if the plane describing that side
// intercepts the planet in such a way that the ellipse of interception does not meet any
// other planes. Plane intersections can each contribute 0, 1, or 2 edgepoints.
//
// All of this makes for a lot of potential edgepoints, but I believe these can be pruned back
// with careful analysis. I haven't yet done that analysis, however, so I will treat them all
// as individual edgepoints.
// The cases we are looking for are when the four corner points for any given
// plane are all outside of the world, AND that plane intersects the world.
// There are eight corner points all told; we must evaluate these WRT the planet surface.
final boolean minXminYminZ = planetModel.pointOutside(minX, minY, minZ);
final boolean minXminYmaxZ = planetModel.pointOutside(minX, minY, maxZ);
final boolean minXmaxYminZ = planetModel.pointOutside(minX, maxY, minZ);
final boolean minXmaxYmaxZ = planetModel.pointOutside(minX, maxY, maxZ);
final boolean maxXminYminZ = planetModel.pointOutside(maxX, minY, minZ);
final boolean maxXminYmaxZ = planetModel.pointOutside(maxX, minY, maxZ);
final boolean maxXmaxYminZ = planetModel.pointOutside(maxX, maxY, minZ);
final boolean maxXmaxYmaxZ = planetModel.pointOutside(maxX, maxY, maxZ);
// System.err.println("Outside world: minXminYminZ="+minXminYminZ+"
// minXminYmaxZ="+minXminYmaxZ+" minXmaxYminZ="+minXmaxYminZ+
// " minXmaxYmaxZ="+minXmaxYmaxZ+" maxXminYminZ="+maxXminYminZ+"
// maxXminYmaxZ="+maxXminYmaxZ+" maxXmaxYminZ="+maxXmaxYminZ+
// " maxXmaxYmaxZ="+maxXmaxYmaxZ);
// Look at single-plane/world intersections.
// We detect these by looking at the world model and noting its x, y, and z bounds.
final GeoPoint[] minXEdges;
if (minX - worldMinX >= -Vector.MINIMUM_RESOLUTION
&& minX - worldMaxX <= Vector.MINIMUM_RESOLUTION
&& minY < 0.0
&& maxY > 0.0
&& minZ < 0.0
&& maxZ > 0.0
&& minXminYminZ
&& minXminYmaxZ
&& minXmaxYminZ
&& minXmaxYmaxZ) {
// Find any point on the minX plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (1,0,0)
// Then use it to compute a sample point.
final GeoPoint intPoint = minXPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane);
if (intPoint != null) {
minXEdges = new GeoPoint[] {intPoint};
} else {
// No intersection found?
minXEdges = EMPTY_POINTS;
}
} else {
minXEdges = EMPTY_POINTS;
}
final GeoPoint[] maxXEdges;
if (maxX - worldMinX >= -Vector.MINIMUM_RESOLUTION
&& maxX - worldMaxX <= Vector.MINIMUM_RESOLUTION
&& minY < 0.0
&& maxY > 0.0
&& minZ < 0.0
&& maxZ > 0.0
&& maxXminYminZ
&& maxXminYmaxZ
&& maxXmaxYminZ
&& maxXmaxYmaxZ) {
// Find any point on the maxX plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (1,0,0)
// Then use it to compute a sample point.
final GeoPoint intPoint = maxXPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane);
if (intPoint != null) {
maxXEdges = new GeoPoint[] {intPoint};
} else {
maxXEdges = EMPTY_POINTS;
}
} else {
maxXEdges = EMPTY_POINTS;
}
final GeoPoint[] minYEdges;
if (minY - worldMinY >= -Vector.MINIMUM_RESOLUTION
&& minY - worldMaxY <= Vector.MINIMUM_RESOLUTION
&& minX < 0.0
&& maxX > 0.0
&& minZ < 0.0
&& maxZ > 0.0
&& minXminYminZ
&& minXminYmaxZ
&& maxXminYminZ
&& maxXminYmaxZ) {
// Find any point on the minY plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (0,1,0)
// Then use it to compute a sample point.
final GeoPoint intPoint = minYPlane.getSampleIntersectionPoint(planetModel, yVerticalPlane);
if (intPoint != null) {
minYEdges = new GeoPoint[] {intPoint};
} else {
minYEdges = EMPTY_POINTS;
}
} else {
minYEdges = EMPTY_POINTS;
}
final GeoPoint[] maxYEdges;
if (maxY - worldMinY >= -Vector.MINIMUM_RESOLUTION
&& maxY - worldMaxY <= Vector.MINIMUM_RESOLUTION
&& minX < 0.0
&& maxX > 0.0
&& minZ < 0.0
&& maxZ > 0.0
&& minXmaxYminZ
&& minXmaxYmaxZ
&& maxXmaxYminZ
&& maxXmaxYmaxZ) {
// Find any point on the maxY plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (0,1,0)
// Then use it to compute a sample point.
final GeoPoint intPoint = maxYPlane.getSampleIntersectionPoint(planetModel, yVerticalPlane);
if (intPoint != null) {
maxYEdges = new GeoPoint[] {intPoint};
} else {
maxYEdges = EMPTY_POINTS;
}
} else {
maxYEdges = EMPTY_POINTS;
}
final GeoPoint[] minZEdges;
if (minZ - worldMinZ >= -Vector.MINIMUM_RESOLUTION
&& minZ - worldMaxZ <= Vector.MINIMUM_RESOLUTION
&& minX < 0.0
&& maxX > 0.0
&& minY < 0.0
&& maxY > 0.0
&& minXminYminZ
&& minXmaxYminZ
&& maxXminYminZ
&& maxXmaxYminZ) {
// Find any point on the minZ plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (1,0,0)
// Then use it to compute a sample point.
final GeoPoint intPoint = minZPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane);
if (intPoint != null) {
minZEdges = new GeoPoint[] {intPoint};
} else {
minZEdges = EMPTY_POINTS;
}
} else {
minZEdges = EMPTY_POINTS;
}
final GeoPoint[] maxZEdges;
if (maxZ - worldMinZ >= -Vector.MINIMUM_RESOLUTION
&& maxZ - worldMaxZ <= Vector.MINIMUM_RESOLUTION
&& minX < 0.0
&& maxX > 0.0
&& minY < 0.0
&& maxY > 0.0
&& minXminYmaxZ
&& minXmaxYmaxZ
&& maxXminYmaxZ
&& maxXmaxYmaxZ) {
// Find any point on the maxZ plane that intersects the world
// First construct a perpendicular plane that will allow us to find a sample point.
// This plane is vertical and goes through the points (0,0,0) and (1,0,0) (that is, its
// orientation doesn't matter)
// Then use it to compute a sample point.
final GeoPoint intPoint = maxZPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane);
if (intPoint != null) {
maxZEdges = new GeoPoint[] {intPoint};
} else {
maxZEdges = EMPTY_POINTS;
}
} else {
maxZEdges = EMPTY_POINTS;
}
// System.err.println(
// " minXEdges="+Arrays.asList(minXEdges)+" maxXEdges="+Arrays.asList(maxXEdges)+
// " minYEdges="+Arrays.asList(minYEdges)+" maxYEdges="+Arrays.asList(maxYEdges)+
// " minZEdges="+Arrays.asList(minZEdges)+" maxZEdges="+Arrays.asList(maxZEdges));
minXPlaneIntersects = notableMinXPoints.length + minXEdges.length > 0;
maxXPlaneIntersects = notableMaxXPoints.length + maxXEdges.length > 0;
minYPlaneIntersects = notableMinYPoints.length + minYEdges.length > 0;
maxYPlaneIntersects = notableMaxYPoints.length + maxYEdges.length > 0;
minZPlaneIntersects = notableMinZPoints.length + minZEdges.length > 0;
maxZPlaneIntersects = notableMaxZPoints.length + maxZEdges.length > 0;
// Glue everything together. This is not a minimal set of edgepoints, as of now, but it does
// completely describe all shapes on the planet.
this.edgePoints =
glueTogether(
minXminY, minXmaxY, minXminZ, minXmaxZ, maxXminY, maxXmaxY, maxXminZ, maxXmaxZ,
minYminZ, minYmaxZ, maxYminZ, maxYmaxZ, minXEdges, maxXEdges, minYEdges, maxYEdges,
minZEdges, maxZEdges);
}
}
/**
* Constructor for deserialization.
*
* @param planetModel is the planet model.
* @param inputStream is the input stream.
*/
public StandardXYZSolid(final PlanetModel planetModel, final InputStream inputStream)
throws IOException {
this(
planetModel,
SerializableObject.readDouble(inputStream),
SerializableObject.readDouble(inputStream),
SerializableObject.readDouble(inputStream),
SerializableObject.readDouble(inputStream),
SerializableObject.readDouble(inputStream),
SerializableObject.readDouble(inputStream));
}
@Override
public void write(final OutputStream outputStream) throws IOException {
SerializableObject.writeDouble(outputStream, minX);
SerializableObject.writeDouble(outputStream, maxX);
SerializableObject.writeDouble(outputStream, minY);
SerializableObject.writeDouble(outputStream, maxY);
SerializableObject.writeDouble(outputStream, minZ);
SerializableObject.writeDouble(outputStream, maxZ);
}
@Override
protected GeoPoint[] getEdgePoints() {
return edgePoints;
}
@Override
public boolean isWithin(final double x, final double y, final double z) {
if (isWholeWorld) {
return true;
}
return minXPlane.isWithin(x, y, z)
&& maxXPlane.isWithin(x, y, z)
&& minYPlane.isWithin(x, y, z)
&& maxYPlane.isWithin(x, y, z)
&& minZPlane.isWithin(x, y, z)
&& maxZPlane.isWithin(x, y, z);
}
@Override
public int getRelationship(final GeoShape path) {
if (isWholeWorld) {
if (path.getEdgePoints().length > 0) return WITHIN;
return OVERLAPS;
}
/*
for (GeoPoint p : getEdgePoints()) {
System.err.println(" Edge point "+p+" path.isWithin()? "+path.isWithin(p));
}
for (GeoPoint p : path.getEdgePoints()) {
System.err.println(" path edge point "+p+" isWithin()? "+isWithin(p)+" minx="+minXPlane.evaluate(p)
+" maxx="+maxXPlane.evaluate(p)+" miny="+minYPlane.evaluate(p)+" maxy="+maxYPlane.evaluate(p)
+" minz="+minZPlane.evaluate(p)+" maxz="+maxZPlane.evaluate(p));
}
*/
// System.err.println(this+" getrelationship with " + path);
final int insideRectangle = isShapeInsideArea(path);
if (insideRectangle == SOME_INSIDE) {
// System.err.println(" some shape points inside area");
return OVERLAPS;
}
// Figure out if the entire XYZArea is contained by the shape.
final int insideShape = isAreaInsideShape(path);
if (insideShape == SOME_INSIDE) {
// System.err.println(" some area points inside shape");
return OVERLAPS;
}
if (insideRectangle == ALL_INSIDE && insideShape == ALL_INSIDE) {
// System.err.println(" inside of each other");
return OVERLAPS;
}
if ((minXPlaneIntersects
&& path.intersects(
minXPlane,
notableMinXPoints,
maxXPlane,
minYPlane,
maxYPlane,
minZPlane,
maxZPlane))
|| (maxXPlaneIntersects
&& path.intersects(
maxXPlane,
notableMaxXPoints,
minXPlane,
minYPlane,
maxYPlane,
minZPlane,
maxZPlane))
|| (minYPlaneIntersects
&& path.intersects(
minYPlane,
notableMinYPoints,
maxYPlane,
minXPlane,
maxXPlane,
minZPlane,
maxZPlane))
|| (maxYPlaneIntersects
&& path.intersects(
maxYPlane,
notableMaxYPoints,
minYPlane,
minXPlane,
maxXPlane,
minZPlane,
maxZPlane))
|| (minZPlaneIntersects
&& path.intersects(
minZPlane,
notableMinZPoints,
maxZPlane,
minXPlane,
maxXPlane,
minYPlane,
maxYPlane))
|| (maxZPlaneIntersects
&& path.intersects(
maxZPlane,
notableMaxZPoints,
minZPlane,
minXPlane,
maxXPlane,
minYPlane,
maxYPlane))) {
// System.err.println(" edges intersect");
return OVERLAPS;
}
if (insideRectangle == ALL_INSIDE) {
// System.err.println(" all shape points inside area");
return WITHIN;
}
if (insideShape == ALL_INSIDE) {
// System.err.println(" all area points inside shape");
return CONTAINS;
}
// System.err.println(" disjoint");
return DISJOINT;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof StandardXYZSolid)) {
return false;
}
StandardXYZSolid other = (StandardXYZSolid) o;
if (!super.equals(other) || other.isWholeWorld != isWholeWorld) {
return false;
}
if (!isWholeWorld) {
return other.minXPlane.equals(minXPlane)
&& other.maxXPlane.equals(maxXPlane)
&& other.minYPlane.equals(minYPlane)
&& other.maxYPlane.equals(maxYPlane)
&& other.minZPlane.equals(minZPlane)
&& other.maxZPlane.equals(maxZPlane);
}
return true;
}
@Override
public int hashCode() {
int result = super.hashCode();
result = 31 * result + (isWholeWorld ? 1 : 0);
if (!isWholeWorld) {
result = 31 * result + minXPlane.hashCode();
result = 31 * result + maxXPlane.hashCode();
result = 31 * result + minYPlane.hashCode();
result = 31 * result + maxYPlane.hashCode();
result = 31 * result + minZPlane.hashCode();
result = 31 * result + maxZPlane.hashCode();
}
return result;
}
@Override
public String toString() {
return "StandardXYZSolid: {planetmodel="
+ planetModel
+ ", isWholeWorld="
+ isWholeWorld
+ ", minXplane="
+ minXPlane
+ ", maxXplane="
+ maxXPlane
+ ", minYplane="
+ minYPlane
+ ", maxYplane="
+ maxYPlane
+ ", minZplane="
+ minZPlane
+ ", maxZplane="
+ maxZPlane
+ "}";
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy