_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q154600 | QuadTreeImpl.getExtent | train | Envelope2D getExtent(int quad_handle) {
Envelope2D quad_extent = new Envelope2D();
quad_extent.setCoords(m_extent);
if (quad_handle == m_root)
return quad_extent;
AttributeStreamOfInt32 quadrants = new AttributeStreamOfInt32(0);
int q = quad_handle;
do {
quadrants.add(get_quadrant_(q));
q = get... | java | {
"resource": ""
} |
q154601 | QuadTreeImpl.getIntersectionCount | train | int getIntersectionCount(Envelope2D query, double tolerance, int max_count) {
if (m_root == -1)
return 0;
Envelope2D query_inflated = new Envelope2D();
query_inflated.setCoords(query);
query_inflated.inflate(tolerance, tolerance);
AttributeStreamOfInt32 quads_stack = new AttributeStreamOfInt32(0);
Arra... | java | {
"resource": ""
} |
q154602 | OperatorSimplifyLocalHelper.isSimplePlanar | train | static protected int isSimplePlanar(/* const */Geometry geometry, /* const */
SpatialReference spatialReference, boolean bForce,
ProgressTracker progressTracker) {
assert (false); // this code is not called yet.
if (geometry.isEmpty())
return 1;
Geometry.Type gt = geometry.getType();
if (gt == Geometry.T... | java | {
"resource": ""
} |
q154603 | OperatorSimplifyLocalHelper.edgeAngleCompare_ | train | private int edgeAngleCompare_(/* const */Edge edge1, /* const */Edge edge2) {
if (edge1.equals(edge2))
return 0;
Point2D v1 = edge1.m_segment._getTangent(edge1.getReversed() ? 1.0
: 0.0);
if (edge1.getReversed())
v1.negate();
Point2D v2 = edge2.m_segment._getTangent(edge2.getReversed() ? 1.0
: 0.... | java | {
"resource": ""
} |
q154604 | EditShape.getEnvelope2D | train | Envelope2D getEnvelope2D() {
Envelope2D env = new Envelope2D();
env.setEmpty();
VertexIterator vert_iter = queryVertexIterator();
Point2D pt = new Point2D();
boolean b_first = true;
for (int ivertex = vert_iter.next(); ivertex != -1; ivertex = vert_iter
.next()) {
getXY(ivertex, pt);
if (b_first)
... | java | {
"resource": ""
} |
q154605 | EditShape.addGeometry | train | int addGeometry(Geometry geometry) {
Geometry.Type gt = geometry.getType();
if (Geometry.isMultiPath(gt.value()))
return addMultiPath_((MultiPath) geometry);
if (gt == Geometry.Type.MultiPoint)
return addMultiPoint_((MultiPoint) geometry);
throw GeometryException.GeometryInternalError();
} | java | {
"resource": ""
} |
q154606 | EditShape.appendGeometry | train | void appendGeometry(int dstGeometry, Geometry srcGeometry) {
Geometry.Type gt = srcGeometry.getType();
if (Geometry.isMultiPath(gt.value())) {
appendMultiPath_(dstGeometry, (MultiPath) srcGeometry);
return;
} else if (gt.value() == Geometry.GeometryType.MultiPoint) {
appendMultiPoint_(dstGeometry, (Multi... | java | {
"resource": ""
} |
q154607 | EditShape.addPathFromMultiPath | train | int addPathFromMultiPath(MultiPath multi_path, int ipath, boolean as_polygon) {
int newgeom = createGeometry(as_polygon ? Geometry.Type.Polygon
: Geometry.Type.Polyline, multi_path.getDescription());
MultiPathImpl mp_impl = (MultiPathImpl) multi_path._getImpl();
if (multi_path.getPathSize(ipath) < 2)
retu... | java | {
"resource": ""
} |
q154608 | EditShape.removeGeometry | train | int removeGeometry(int geometry) {
for (int path = getFirstPath(geometry); path != -1; path = removePath(path)) {
// removing paths in a loop
}
int prev = getPrevGeometry(geometry);
int next = getNextGeometry(geometry);
if (prev != -1)
setNextGeometry_(prev, next);
else {
m_first_geometry = next;
... | java | {
"resource": ""
} |
q154609 | EditShape.createGeometry | train | int createGeometry(Geometry.Type geometry_type,
VertexDescription description) {
int newgeom = newGeometry_(geometry_type.value());
if (m_vertices == null) {
m_vertices_mp = new MultiPoint(description);
m_vertices = (MultiPointImpl) m_vertices_mp._getImpl();
} else
m_vertices_mp.mergeVertexDescription... | java | {
"resource": ""
} |
q154610 | EditShape.setGeometryUserIndex | train | void setGeometryUserIndex(int geom, int index, int value) {
AttributeStreamOfInt32 stream = m_geometry_indices.get(index);
int pindex = getGeometryIndex_(geom);
if (pindex >= stream.size())
stream.resize(Math.max((int) (pindex * 1.25), (int) 16), -1);
stream.write(pindex, value);
} | java | {
"resource": ""
} |
q154611 | EditShape.getGeometryUserIndex | train | int getGeometryUserIndex(int geom, int index) {
int pindex = getGeometryIndex_(geom);
AttributeStreamOfInt32 stream = m_geometry_indices.get(index);
if (pindex < stream.size())
return stream.read(pindex);
else
return -1;
} | java | {
"resource": ""
} |
q154612 | EditShape.createGeometryUserIndex | train | int createGeometryUserIndex() {
if (m_geometry_indices == null)
m_geometry_indices = new ArrayList<AttributeStreamOfInt32>(4);
// Try getting existing index. Use linear search. We do not expect many
// indices to be created.
for (int i = 0; i < m_geometry_indices.size(); i++) {
if (m_geometry_indices.get... | java | {
"resource": ""
} |
q154613 | EditShape.hasDegenerateSegments | train | boolean hasDegenerateSegments(double tolerance) {
for (int geometry = getFirstGeometry(); geometry != -1; geometry = getNextGeometry(geometry)) {
if (!Geometry.isMultiPath(getGeometryType(geometry)))
continue;
boolean b_polygon = getGeometryType(geometry) == Geometry.GeometryType.Polygon;
for (int path... | java | {
"resource": ""
} |
q154614 | EditShape.splitSegment | train | int splitSegment(int origin_vertex, double[] split_scalars, int split_count) {
int actual_splits = 0;
int next_vertex = getNextVertex(origin_vertex);
if (next_vertex == -1)
throw GeometryException.GeometryInternalError();
int vindex = getVertexIndex(origin_vertex);
int vindex_next = getVertexIndex(next_ve... | java | {
"resource": ""
} |
q154615 | EditShape.createUserIndex | train | int createUserIndex() {
if (m_indices == null)
m_indices = new ArrayList<AttributeStreamOfInt32>(0);
// Try getting existing index. Use linear search. We do not expect many
// indices to be created.
for (int i = 0; i < m_indices.size(); i++) {
if (m_indices.get(i) == null) {
m_indices.set(i, (Attribu... | java | {
"resource": ""
} |
q154616 | EditShape.getSegment | train | Segment getSegment(int vertex) {
if (m_segments != null) {
int vindex = getVertexIndex(vertex);
return m_segments.get(vindex);
}
return null;
} | java | {
"resource": ""
} |
q154617 | EditShape.queryLineConnector | train | boolean queryLineConnector(int vertex, Line line) {
int next = getNextVertex(vertex);
if (next == -1)
return false;
if (!m_b_has_attributes) {
Point2D pt = new Point2D();
getXY(vertex, pt);
line.setStartXY(pt);
getXY(next, pt);
line.setEndXY(pt);
} else {
Point pt = new Point();
queryPo... | java | {
"resource": ""
} |
q154618 | EditShape.insertPath | train | int insertPath(int geometry, int before_path) {
int prev = -1;
if (before_path != -1) {
if (geometry != getGeometryFromPath(before_path))
throw GeometryException.GeometryInternalError();
prev = getPrevPath(before_path);
} else
prev = getLastPath(geometry);
int newpath = newPath_(geometry);
if ... | java | {
"resource": ""
} |
q154619 | EditShape.removePath | train | int removePath(int path) {
int prev = getPrevPath(path);
int next = getNextPath(path);
int geometry = getGeometryFromPath(path);
if (prev != -1)
setNextPath_(prev, next);
else {
setFirstPath_(geometry, next);
}
if (next != -1)
setPrevPath_(next, prev);
else {
setLastPath_(geometry, prev);
... | java | {
"resource": ""
} |
q154620 | EditShape.clearPath | train | void clearPath(int path) {
int first_vertex = getFirstVertex(path);
if (first_vertex != -1) {
// TODO: can ve do this in one shot?
int vertex = first_vertex;
for (int i = 0, n = getPathSize(path); i < n; i++) {
int v = vertex;
vertex = getNextVertex(vertex);
freeVertex_(v);
}
int geometry... | java | {
"resource": ""
} |
q154621 | EditShape.getRingArea | train | double getRingArea(int path) {
if (isRingAreaValid_(path))
return m_path_areas.get(getPathIndex_(path));
Line line = new Line();
int vertex = getFirstVertex(path);
if (vertex == -1)
return 0;
Point2D pt0 = new Point2D();
getXY(vertex, pt0);
double area = 0;
for (int i = 0, n = getPathSize(path); ... | java | {
"resource": ""
} |
q154622 | EditShape.setPathUserIndex | train | void setPathUserIndex(int path, int index, int value) {
AttributeStreamOfInt32 stream = m_pathindices.get(index);
int pindex = getPathIndex_(path);
if (stream.size() < m_path_areas.size())
stream.resize(m_path_areas.size(), -1);
stream.write(pindex, value);
} | java | {
"resource": ""
} |
q154623 | EditShape.getPathUserIndex | train | int getPathUserIndex(int path, int index) {
int pindex = getPathIndex_(path);
AttributeStreamOfInt32 stream = m_pathindices.get(index);
if (pindex < stream.size())
return stream.read(pindex);
else
return -1;
} | java | {
"resource": ""
} |
q154624 | EditShape.createPathUserIndex | train | int createPathUserIndex() {
if (m_pathindices == null)
m_pathindices = new ArrayList<AttributeStreamOfInt32>(0);
// Try getting existing index. Use linear search. We do not expect many
// indices to be created.
for (int i = 0; i < m_pathindices.size(); i++) {
if (m_pathindices.get(i) == null) {
m_path... | java | {
"resource": ""
} |
q154625 | EditShape.movePath | train | void movePath(int geom, int before_path, int path_to_move) {
if (path_to_move == -1)
throw new IllegalArgumentException();
if (before_path == path_to_move)
return;
int next = getNextPath(path_to_move);
int prev = getPrevPath(path_to_move);
int geom_src = getGeometryFromPath(path_to_move);
if (prev =... | java | {
"resource": ""
} |
q154626 | EditShape.addVertex | train | int addVertex(int path, int vertex) {
m_vertices.getPointByVal(getVertexIndex(vertex), getHelperPoint_());
return insertVertex_(path, -1, getHelperPoint_());
} | java | {
"resource": ""
} |
q154627 | EditShape.removeVertex | train | int removeVertex(int vertex, boolean b_left_segment) {
int path = getPathFromVertex(vertex);
int prev = getPrevVertex(vertex);
int next = getNextVertex(vertex);
if (prev != -1)
setNextVertex_(prev, next);
int path_size = getPathSize(path);
if (vertex == getFirstVertex(path)) {
setFirstVertex_(path, ... | java | {
"resource": ""
} |
q154628 | EditShape.applyTransformation | train | void applyTransformation(Transformation2D transform) {
m_vertices_mp.applyTransformation(transform);
if (m_segments != null) {
for (int i = 0, n = m_segments.size(); i < n; i++) {
if (m_segments.get(i) != null) {
m_segments.get(i).applyTransformation(transform);
}
}
}
} | java | {
"resource": ""
} |
q154629 | QuadTree.insert | train | public int insert(int element, Envelope2D boundingBox, int hintIndex) {
return m_impl.insert(element, boundingBox, hintIndex);
} | java | {
"resource": ""
} |
q154630 | QuadTree.getIntersectionCount | train | public int getIntersectionCount(Envelope2D query, double tolerance, int maxCount) {
return m_impl.getIntersectionCount(query, tolerance, maxCount);
} | java | {
"resource": ""
} |
q154631 | QuadTree.getIterator | train | public QuadTreeIterator getIterator(Geometry query, double tolerance) {
QuadTreeImpl.QuadTreeIteratorImpl iterator = m_impl.getIterator(query, tolerance);
return new QuadTreeIterator(iterator, false);
} | java | {
"resource": ""
} |
q154632 | QuadTree.getIterator | train | public QuadTreeIterator getIterator() {
QuadTreeImpl.QuadTreeIteratorImpl iterator = m_impl.getIterator();
return new QuadTreeIterator(iterator, false);
} | java | {
"resource": ""
} |
q154633 | QuadTree.getIterator | train | public QuadTreeIterator getIterator(Geometry query, double tolerance, boolean bSorted) {
if (!bSorted) {
QuadTreeImpl.QuadTreeIteratorImpl iterator = m_impl.getIterator(query, tolerance);
return new QuadTreeIterator(iterator, false);
} else {
QuadTreeImpl.QuadTreeSortedIteratorImpl iterator = m_impl.getSor... | java | {
"resource": ""
} |
q154634 | QuadTree.getIterator | train | public QuadTreeIterator getIterator(boolean bSorted) {
if (!bSorted) {
QuadTreeImpl.QuadTreeIteratorImpl iterator = m_impl.getIterator();
return new QuadTreeIterator(iterator, false);
} else {
QuadTreeImpl.QuadTreeSortedIteratorImpl iterator = m_impl.getSortedIterator();
return new QuadTreeIterator(iter... | java | {
"resource": ""
} |
q154635 | Segment.getCoord2D | train | public Point2D getCoord2D(double t) {
Point2D pt = new Point2D();
getCoord2D(t, pt);
return pt;
} | java | {
"resource": ""
} |
q154636 | MultiPathImpl.startPath | train | public void startPath(double x, double y) {
Point2D endPoint = new Point2D();
endPoint.x = x;
endPoint.y = y;
startPath(endPoint);
} | java | {
"resource": ""
} |
q154637 | MultiPathImpl.bezierTo | train | public void bezierTo(Point2D controlPoint1, Point2D controlPoint2,
Point2D endPoint) {
_beforeNewSegment(1);
setXY(m_pointCount - 1, endPoint);
double z;
_initSegmentData(6);
m_pathFlags.setBits(m_pathFlags.size() - 1,
(byte) PathFlags.enumHasNonlinearSegments);
m_segmentParamIndex.write(m_pointCount... | java | {
"resource": ""
} |
q154638 | MultiPathImpl.openAllPathsAndDuplicateStartVertex | train | public void openAllPathsAndDuplicateStartVertex() {
_touch();
if (m_bPolygon)
throw GeometryException.GeometryInternalError();// do not call this
// method on a
// polygon
if (m_pathFlags == null)// if (!m_pathFlags)
throw GeometryException.GeometryInternalError();
_verifyA... | java | {
"resource": ""
} |
q154639 | MultiPathImpl.closeAllPaths | train | public void closeAllPaths() {
_touch();
if (m_bPolygon || isEmptyImpl())
return;
m_bPathStarted = false;
for (int ipath = 0, npart = m_paths.size() - 1; ipath < npart; ipath++) {
if (isClosedPath(ipath))
continue;
byte pf = m_pathFlags.read(ipath);
m_pathFlags.write(ipath, (byte) (pf | PathFl... | java | {
"resource": ""
} |
q154640 | MultiPathImpl.closePathWithBezier | train | public void closePathWithBezier(Point2D controlPoint1, Point2D controlPoint2) {
_touch();
if (isEmptyImpl())
throw new GeometryException(
"Invalid call. This operation cannot be performed on an empty geometry.");
m_bPathStarted = false;
int pathIndex = m_paths.size() - 2;
byte pf = m_pathFlags.read(... | java | {
"resource": ""
} |
q154641 | OperatorIntersectionCursor.prepareVector_ | train | GeometryCursor prepareVector_(VertexDescription descr, int dimensionMask,
Geometry[] res_vec) {
int inext = 0;
if ((dimensionMask & 1) != 0) {
if (res_vec[0] == null)
res_vec[0] = new MultiPoint(descr);
inext++;
} else {
for (int i = 0; i < res_vec.length - 1; i++)
res_vec[i] = res_vec[i + 1];... | java | {
"resource": ""
} |
q154642 | SweepComparator.tryGetCachedEdge_ | train | SimpleEdge tryGetCachedEdge_(int value) {
SimpleEdge se = m_simple_edges_cache.get((value & NumberUtils.intMax())
% m_simple_edges_cache.size());
if (se != null) {
if (se.m_value == value)
return se;
else {
// int i = 0;
// cache collision
}
}
return null;
} | java | {
"resource": ""
} |
q154643 | SweepComparator.tryDeleteCachedEdge_ | train | void tryDeleteCachedEdge_(int value) {
int ind = (value & NumberUtils.intMax()) % m_simple_edges_cache.size();
SimpleEdge se = m_simple_edges_cache.get(ind);
if (se != null && se.m_value == value) {// this value is cached
m_simple_edges_recycle.add(se);
m_simple_edges_cache.set(ind, null);
} else {
// ... | java | {
"resource": ""
} |
q154644 | SweepComparator.tryCreateCachedEdge_ | train | SimpleEdge tryCreateCachedEdge_(int value) {
int ind = (value & NumberUtils.intMax()) % m_simple_edges_cache.size();
SimpleEdge se = m_simple_edges_cache.get(ind);
if (se == null) {
if (m_simple_edges_recycle.isEmpty()) {
// assert(m_simple_edges_buffer.size() <
// m_simple_edges_buffer.capacity());//s... | java | {
"resource": ""
} |
q154645 | SweepComparator.compareTwoSegments_ | train | int compareTwoSegments_(Segment seg_1, Segment seg_2) {
int res = seg_1._isIntersecting(seg_2, m_tolerance, true);
if (res != 0) {
if (res == 2)
return errorCoincident();
else
return errorCracking();
}
Point2D start_1 = seg_1.getStartXY();
Point2D end1 = seg_1.getEndXY();
Point2D start2 = seg... | java | {
"resource": ""
} |
q154646 | SweepComparator.setSweepY | train | void setSweepY(double y, double x) {
// _ASSERT(m_sweep_y != y || m_sweep_x != x);
m_sweep_y = y;
m_sweep_x = x;
m_prev_1 = -1;
m_prev_2 = -1;
m_vertex_1 = -1;
m_vertex_2 = -1;
} | java | {
"resource": ""
} |
q154647 | Envelope2D.setFromPoints | train | public void setFromPoints(Point2D[] points) {
if (points == null || points.length == 0) {
setEmpty();
return;
}
Point2D pt = points[0];
setCoords(pt.x, pt.y);
for (int i = 1; i < points.length; i++) {
Point2D pt2d = points[i];
mergeNE(pt2d.x, pt2d.y);
}
} | java | {
"resource": ""
} |
q154648 | Envelope2D.mergeNE | train | public void mergeNE(double x, double y) {
if (xmin > x)
xmin = x;
else if (xmax < x)
xmax = x;
if (ymin > y)
ymin = y;
else if (ymax < y)
ymax = y;
} | java | {
"resource": ""
} |
q154649 | Envelope2D.isIntersectingNE | train | public boolean isIntersectingNE(Envelope2D other) {
return ((xmin <= other.xmin) ? xmax >= other.xmin : other.xmax >= xmin)
&& // check that x projections overlap
((ymin <= other.ymin) ? ymax >= other.ymin : other.ymax >= ymin); // check
// that
// y
... | java | {
"resource": ""
} |
q154650 | Envelope2D.queryCorner | train | public Point2D queryCorner(int index) {
switch (index) {
case 0:
return Point2D.construct(xmin, ymin);
case 1:
return Point2D.construct(xmin, ymax);
case 2:
return Point2D.construct(xmax, ymax);
case 3:
return Point2D.construct(xmax, ymin);
default:
throw new IndexOutOfBoundsException();
}... | java | {
"resource": ""
} |
q154651 | Envelope2D.queryCorners | train | public void queryCorners(Point2D[] corners) {
if ((corners == null) || (corners.length < 4))
throw new IllegalArgumentException();
if (corners[0] != null)
corners[0].setCoords(xmin, ymin);
else
corners[0] = new Point2D(xmin, ymin);
if (corners[1] != null)
corners[1].setCoords(xmin, ymax);
else
... | java | {
"resource": ""
} |
q154652 | Envelope2D.move | train | public void move(double dx, double dy) {
if (isEmpty())
return;
xmin += dx;
ymin += dy;
xmax += dx;
ymax += dy;
} | java | {
"resource": ""
} |
q154653 | Envelope2D._boundaryDistance | train | double _boundaryDistance(Point2D pt) {
if (isEmpty())
return NumberUtils.NaN();
if (pt.x == xmin)
return pt.y - ymin;
double height = ymax - ymin;
double width = xmax - xmin;
if (pt.y == ymax)
return height + pt.x - xmin;
if (pt.x == xmax)
return height + width + ymax - pt.y;
if (pt.y == ... | java | {
"resource": ""
} |
q154654 | Envelope2D._envelopeSide | train | int _envelopeSide(Point2D pt) {
if (isEmpty())
return -1;
double boundaryDist = _boundaryDistance(pt);
double height = ymax - ymin;
double width = xmax - xmin;
if (boundaryDist < height)
return 0;
if ((boundaryDist -= height) < width)
return 1;
return boundaryDist - width < height ? 2 : 3;
... | java | {
"resource": ""
} |
q154655 | Envelope2D.clipLine | train | int clipLine(Point2D p0, Point2D p1, int lineExtension, double[] segParams,
double[] boundaryDistances) {
if (boundaryDistances != null) {
boundaryDistances[0] = -1.0;
boundaryDistances[1] = -1.0;
}
double[] tOld = new double[2];// LOCALREFCLASS1(ArrayOf(double), int,
// tOld, 2);
int modifi... | java | {
"resource": ""
} |
q154656 | Envelope2D.sqrMaxDistance | train | public double sqrMaxDistance(Envelope2D other) {
if (isEmpty() || other.isEmpty())
return NumberUtils.TheNaN;
double dist = 0;
Point2D[] points = new Point2D[4];
queryCorners(points);
Point2D[] points_o = new Point2D[4];
other.queryCorners(points_o);
for (int i = 0; i < 4; i++) {
for (int j = 0; j ... | java | {
"resource": ""
} |
q154657 | Envelope2D.sqrDistance | train | public double sqrDistance(Point2D pt2D)
{
double dx = 0;
double dy = 0;
double nn;
nn = xmin - pt2D.x;
if (nn > dx)
dx = nn;
nn = ymin - pt2D.y;
if (nn > dy)
dy = nn;
nn = pt2D.x - xmax;
if (nn > dx)
dx = nn;
nn = pt2D.y - ymax;
if (nn > dy)
dy = nn;
return dx * dx + dy * dy;
... | java | {
"resource": ""
} |
q154658 | MultiVertexGeometryImpl.setEnvelope | train | public void setEnvelope(Envelope env) {
if (!m_description.equals(env.getDescription()))
throw new IllegalArgumentException();
// m_envelope = (Envelope) env.clone();
m_envelope = (Envelope) env.createInstance();
env.copyTo(m_envelope);
_setDirtyFlag(DirtyFlags.DirtyIntervals, false);
} | java | {
"resource": ""
} |
q154659 | MultiVertexGeometryImpl._copyToUnsafe | train | void _copyToUnsafe(MultiVertexGeometryImpl dst) {
_verifyAllStreams();
dst.m_description = m_description;
dst.m_vertexAttributes = null;
int nattrib = m_description.getAttributeCount();
AttributeStreamBase[] cloneAttributes = null;
if (m_vertexAttributes != null) {
cloneAttributes = new AttributeStreamBa... | java | {
"resource": ""
} |
q154660 | MultiVertexGeometryImpl.notifyModified | train | public void notifyModified(int flags) {
if (flags == DirtyFlags.DirtyAll) {
m_reservedPointCount = -1;// forget the reserved point number
_notifyModifiedAllImpl();
}
m_flagsMask |= flags;
_clearAccelerators();
_touch();
} | java | {
"resource": ""
} |
q154661 | MultiVertexGeometryImpl._updateXYImpl | train | public void _updateXYImpl(boolean bExact) {
m_envelope.setEmpty();
AttributeStreamOfDbl stream = (AttributeStreamOfDbl) m_vertexAttributes[0];
Point2D pt = new Point2D();
for (int i = 0; i < m_pointCount; i++) {
stream.read(2 * i, pt);
m_envelope.merge(pt);
}
} | java | {
"resource": ""
} |
q154662 | MultiVertexGeometryImpl.getIsSimple | train | public int getIsSimple(double tolerance) {
if (!_hasDirtyFlag(DirtyFlags.DirtyIsKnownSimple)) {
if (!_hasDirtyFlag(DirtyFlags.IsWeakSimple)) {
return 0;
}
if (m_simpleTolerance >= tolerance) {
if (!_hasDirtyFlag(DirtyFlags.DirtyOGCFlags))
return 2;
return 1;
}
return -1;
}
return... | java | {
"resource": ""
} |
q154663 | Cracker.needsCracking | train | static boolean needsCracking(boolean allowCoincident, EditShape shape, double tolerance,
NonSimpleResult result, ProgressTracker progress_tracker) {
if (!canBeCracked(shape))
return false;
Cracker cracker = new Cracker(progress_tracker);
cracker.m_shape = shape;
cracker.m_tolerance = tolerance;
cracker... | java | {
"resource": ""
} |
q154664 | OGCGeometry.isSimpleRelaxed | train | public boolean isSimpleRelaxed() {
OperatorSimplify op = (OperatorSimplify) OperatorFactoryLocal
.getInstance().getOperator(Operator.Type.Simplify);
return op.isSimpleAsFeature(getEsriGeometry(), esriSR, true, null, null);
} | java | {
"resource": ""
} |
q154665 | OGCGeometry.makeSimpleRelaxed | train | public OGCGeometry makeSimpleRelaxed(boolean forceProcessing) {
OperatorSimplify op = (OperatorSimplify) OperatorFactoryLocal
.getInstance().getOperator(Operator.Type.Simplify);
return OGCGeometry.createFromEsriGeometry(
op.execute(getEsriGeometry(), esriSR, forceProcessing, null),
esriSR);
} | java | {
"resource": ""
} |
q154666 | OGCGeometry.simplifyBunch_ | train | private OGCGeometry simplifyBunch_(GeometryCursor gc) {
// Combines geometries into multipoint, polyline, and polygon types,
// simplifying them and unioning them,
// then produces OGCGeometry from the result.
// Can produce OGCConcreteGoemetryCollection
MultiPoint dstMultiPoint = null;
ArrayList<Geometry> ... | java | {
"resource": ""
} |
q154667 | OGCGeometry.createFromEsriCursor | train | public static OGCGeometry createFromEsriCursor(GeometryCursor gc,
SpatialReference sr) {
return createFromEsriCursor(gc, sr, false);
} | java | {
"resource": ""
} |
q154668 | PlaneSweepCrackerHelper.sweepVertical | train | boolean sweepVertical(EditShape shape, double tolerance) {
setEditShape_(shape);
m_b_cracked = false;
m_tolerance = tolerance;
m_tolerance_sqr = tolerance * tolerance;
m_complications = false;
boolean bresult = sweepImpl_();
if (!m_complications) {
int filtered = shape.filterClosePoints(tolerance, true... | java | {
"resource": ""
} |
q154669 | PlaneSweepCrackerHelper.newEdge_ | train | int newEdge_(int origin_vertex) {
int edge = m_edges.newElement();
int edgeVertices = m_edge_vertices.createList();
setEdgeOriginVertices_(edge, edgeVertices);
if (origin_vertex != -1)
m_edge_vertices.addElement(edgeVertices, origin_vertex);
return edge;
} | java | {
"resource": ""
} |
q154670 | PlaneSweepCrackerHelper.mergeClusters_ | train | void mergeClusters_(int cluster_1, int cluster2) {
// dbg_check_cluster_(cluster_1);
// dbg_check_cluster_(cluster2);
int eventQnode = getClusterEventQNode(cluster2);
if (eventQnode != -1) {
m_event_q.deleteNode(eventQnode, -1);
setClusterEventQNode_(cluster2, -1);
}
int firstEdge1 = getClusterFirstE... | java | {
"resource": ""
} |
q154671 | PlaneSweepCrackerHelper.mergeEdges_ | train | void mergeEdges_(int edge1, int edge2) {
// dbg_check_edge_(edge1);
int cluster_1 = getEdgeCluster(edge1, 0);
int cluster2 = getEdgeCluster(edge1, 1);
int cluster21 = getEdgeCluster(edge2, 0);
int cluster22 = getEdgeCluster(edge2, 1);
int originVertices1 = getEdgeOriginVertices(edge1);
int originVertices... | java | {
"resource": ""
} |
q154672 | PlaneSweepCrackerHelper.disconnectEdge_ | train | void disconnectEdge_(int edge) {
int cluster_1 = getEdgeCluster(edge, 0);
int cluster2 = getEdgeCluster(edge, 1);
disconnectEdgeFromCluster_(edge, cluster_1);
disconnectEdgeFromCluster_(edge, cluster2);
} | java | {
"resource": ""
} |
q154673 | PlaneSweepCrackerHelper.disconnectEdgeFromCluster_ | train | void disconnectEdgeFromCluster_(int edge, int cluster) {
int next = getNextEdge(edge, cluster);
assert (getPrevEdge(next, cluster) == edge);
int prev = getPrevEdge(edge, cluster);
assert (getNextEdge(prev, cluster) == edge);
int first_edge = getClusterFirstEdge(cluster);
if (next != edge) {
setNextEdge_(... | java | {
"resource": ""
} |
q154674 | PlaneSweepCrackerHelper.fillEventQueue | train | void fillEventQueue() {
AttributeStreamOfInt32 event_q = new AttributeStreamOfInt32(0);
event_q.reserve(m_shape.getTotalPointCount());// temporary structure to
// sort and find
// clusters
EditShape.VertexIterator iter = m_shape.queryVertexIterator();
for (int vert = iter.next(); ver... | java | {
"resource": ""
} |
q154675 | PlaneSweepCrackerHelper.getAffectedEdges | train | void getAffectedEdges(int cluster, AttributeStreamOfInt32 edges) {
int first_edge = getClusterFirstEdge(cluster);
if (first_edge == -1)
return;
int edge = first_edge;
do {
int sweepNode = getEdgeSweepNode(edge);
if (StridedIndexTypeCollection.isValidElement(sweepNode)) {
edges.add(edge);
}
e... | java | {
"resource": ""
} |
q154676 | PlaneSweepCrackerHelper.updateClusterXY | train | void updateClusterXY(int cluster, Point2D pt) {
int vertexList = getClusterVertices(cluster);
for (int vh = m_cluster_vertices.getFirst(vertexList); vh != -1; vh = m_cluster_vertices
.getNext(vh)) {
int vertex = m_cluster_vertices.getElement(vh);
m_shape.setXY(vertex, pt);
}
} | java | {
"resource": ""
} |
q154677 | PlaneSweepCrackerHelper.getClusterXY | train | void getClusterXY(int cluster, Point2D ptOut) {
int vindex = getClusterVertexIndex(cluster);
m_shape.getXYWithIndex(vindex, ptOut);
} | java | {
"resource": ""
} |
q154678 | Clusterer.executeNonReciprocal | train | static boolean executeNonReciprocal(EditShape shape, double tolerance) {
Clusterer clusterer = new Clusterer();
clusterer.m_shape = shape;
clusterer.m_tolerance = tolerance;
clusterer.m_sqr_tolerance = tolerance * tolerance;
clusterer.m_cell_size = 2 * tolerance;
clusterer.m_inv_cell_size = 1.0 / clusterer.... | java | {
"resource": ""
} |
q154679 | Clusterer.isClusterCandidate_ | train | static boolean isClusterCandidate_(double x_1, double y1, double x2,
double y2, double sqr_tolerance) {
double dx = x_1 - x2;
double dy = y1 - y2;
return dx * dx + dy * dy <= sqr_tolerance;
} | java | {
"resource": ""
} |
q154680 | Clusterer.mergeVertices | train | static boolean mergeVertices(Point pt_1, Point pt_2, double w_1,
int rank_1, double w_2, int rank_2, Point pt_res, double[] w_res,
int[] rank_res) {
assert (!pt_1.isEmpty() && !pt_2.isEmpty());
boolean res = pt_1.equals(pt_2);
if (rank_1 > rank_2) {
pt_res = pt_1;
if (w_res != null) {
rank_res[0]... | java | {
"resource": ""
} |
q154681 | OperatorDifferenceLocal.pointMinusPolygon_ | train | static Geometry pointMinusPolygon_(Point point, Polygon polygon,
double tolerance, ProgressTracker progress_tracker) {
PolygonUtils.PiPResult result = PolygonUtils.isPointInPolygon2D(
polygon, point, tolerance);
if (result == PolygonUtils.PiPResult.PiPOutside)
return point;
return point.createInstance... | java | {
"resource": ""
} |
q154682 | TopologicalOperations.dissolveCommonEdges_ | train | void dissolveCommonEdges_() {
int visitedEdges = m_topo_graph.createUserIndexForHalfEdges();
AttributeStreamOfInt32 edgesToDelete = new AttributeStreamOfInt32(0);
// Now extract paths that
for (int cluster = m_topo_graph.getFirstCluster(); cluster != -1; cluster = m_topo_graph
.getNextCluster(cluster)) {
... | java | {
"resource": ""
} |
q154683 | JsonParserReader.createFromStringNNT | train | public static JsonReader createFromStringNNT(String str) {
try {
JsonFactory factory = new JsonFactory();
JsonParser jsonParser = factory.createParser(str);
return new JsonParserReader(jsonParser);
}
catch (Exception ex) {
throw new JsonGeometryException(ex.getMessage());
}
} | java | {
"resource": ""
} |
q154684 | Operator.deaccelerateGeometry | train | public static void deaccelerateGeometry(Geometry geometry) {
Geometry.Type gt = geometry.getType();
if (Geometry.isMultiVertex(gt.value()))
{
GeometryAccelerators accel = ((MultiVertexGeometryImpl) geometry
._getImpl())._getAccelerators();
if (accel != null){
accel._setRasterizedGeometry(null);
... | java | {
"resource": ""
} |
q154685 | RelationalOperations.relate | train | private static boolean relate(Point point_a, Envelope envelope_b,
SpatialReference sr, int relation, ProgressTracker progress_tracker) {
if (point_a.isEmpty() || envelope_b.isEmpty()) {
if (relation == Relation.disjoint)
return true; // Always true
return false; // Always false
}
Point2D pt_a = poi... | java | {
"resource": ""
} |
q154686 | RelationalOperations.relate | train | private static boolean relate(Point point_a, Point point_b,
SpatialReference sr, int relation, ProgressTracker progress_tracker) {
if (point_a.isEmpty() || point_b.isEmpty()) {
if (relation == Relation.disjoint)
return true; // Always true
return false; // Always false
}
Point2D pt_a = point_a.getX... | java | {
"resource": ""
} |
q154687 | RelationalOperations.polygonEqualsPolygon_ | train | private static boolean polygonEqualsPolygon_(Polygon polygon_a,
Polygon polygon_b, double tolerance,
ProgressTracker progress_tracker) {
Envelope2D env_a = new Envelope2D(), env_b = new Envelope2D();
polygon_a.queryEnvelope2D(env_a);
polygon_b.queryEnvelope2D(env_b);
// Quick envelope rejection test for ... | java | {
"resource": ""
} |
q154688 | RelationalOperations.polygonDisjointPolygon_ | train | private static boolean polygonDisjointPolygon_(Polygon polygon_a,
Polygon polygon_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygon_a... | java | {
"resource": ""
} |
q154689 | RelationalOperations.polygonTouchesPolygon_ | train | private static boolean polygonTouchesPolygon_(Polygon polygon_a,
Polygon polygon_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygon_a,... | java | {
"resource": ""
} |
q154690 | RelationalOperations.polygonOverlapsPolygon_ | train | private static boolean polygonOverlapsPolygon_(Polygon polygon_a,
Polygon polygon_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygon_a... | java | {
"resource": ""
} |
q154691 | RelationalOperations.polygonContainsPolygon_ | train | private static boolean polygonContainsPolygon_(Polygon polygon_a,
Polygon polygon_b, double tolerance,
ProgressTracker progress_tracker) {
Envelope2D env_a = new Envelope2D(), env_b = new Envelope2D();
polygon_a.queryEnvelope2D(env_a);
polygon_b.queryEnvelope2D(env_b);
// Quick envelope rejection test fo... | java | {
"resource": ""
} |
q154692 | RelationalOperations.polygonDisjointPolyline_ | train | private static boolean polygonDisjointPolyline_(Polygon polygon_a,
Polyline polyline_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygo... | java | {
"resource": ""
} |
q154693 | RelationalOperations.polygonTouchesPolyline_ | train | private static boolean polygonTouchesPolyline_(Polygon polygon_a,
Polyline polyline_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygon... | java | {
"resource": ""
} |
q154694 | RelationalOperations.polygonCrossesPolyline_ | train | private static boolean polygonCrossesPolyline_(Polygon polygon_a,
Polyline polyline_b, double tolerance,
ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRasterizedContainsOrDisjoint_(polygon... | java | {
"resource": ""
} |
q154695 | RelationalOperations.polygonContainsPolyline_ | train | private static boolean polygonContainsPolyline_(Polygon polygon_a,
Polyline polyline_b, double tolerance,
ProgressTracker progress_tracker) {
Envelope2D env_a = new Envelope2D(), env_b = new Envelope2D();
polygon_a.queryEnvelope2D(env_a);
polyline_b.queryEnvelope2D(env_b);
// Quick envelope rejection tes... | java | {
"resource": ""
} |
q154696 | RelationalOperations.polygonDisjointPoint_ | train | private static boolean polygonDisjointPoint_(Polygon polygon_a,
Point point_b, double tolerance, ProgressTracker progress_tracker) {
PolygonUtils.PiPResult result = PolygonUtils.isPointInPolygon2D(
polygon_a, point_b, tolerance);
if (result == PolygonUtils.PiPResult.PiPOutside)
return true;
return fal... | java | {
"resource": ""
} |
q154697 | RelationalOperations.polygonTouchesPoint_ | train | private static boolean polygonTouchesPoint_(Polygon polygon_a,
Point point_b, double tolerance, ProgressTracker progress_tracker) {
Point2D pt_b = point_b.getXY();
return polygonTouchesPointImpl_(polygon_a, pt_b, tolerance, null);
} | java | {
"resource": ""
} |
q154698 | RelationalOperations.polygonContainsPoint_ | train | private static boolean polygonContainsPoint_(Polygon polygon_a,
Point point_b, double tolerance, ProgressTracker progress_tracker) {
Point2D pt_b = point_b.getXY();
return polygonContainsPointImpl_(polygon_a, pt_b, tolerance,
progress_tracker);
} | java | {
"resource": ""
} |
q154699 | RelationalOperations.polygonDisjointMultiPoint_ | train | private static boolean polygonDisjointMultiPoint_(Polygon polygon_a,
MultiPoint multipoint_b, double tolerance,
boolean bIncludeBoundaryA, ProgressTracker progress_tracker) {
// Quick rasterize test to see whether the the geometries are disjoint,
// or if one is contained in the other.
int relation = tryRas... | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.