idx int64 0 41.2k | question stringlengths 73 5.81k | target stringlengths 5 918 |
|---|---|---|
26,200 | int deleteEdgeInternal_ ( int half_edge ) { int chain = getHalfEdgeChain ( half_edge ) ; int halfEdgeTwin = getHalfEdgeTwin ( half_edge ) ; int chainTwin = getHalfEdgeChain ( halfEdgeTwin ) ; assert ( chainTwin == chain ) ; assert ( half_edge == getHalfEdgeNext ( halfEdgeTwin ) || halfEdgeTwin == getHalfEdgeNext ( half_edge ) ) ; int n = getHalfEdgeNext ( half_edge ) ; if ( n == halfEdgeTwin ) { n = getHalfEdgeNext ( n ) ; if ( n == half_edge ) n = - 1 ; } if ( getChainHalfEdge ( chain ) == half_edge ) { setChainHalfEdge_ ( chain , n ) ; } int chainIndex = getChainIndex_ ( chain ) ; double v = m_chainAreas . read ( chainIndex ) ; if ( ! NumberUtils . isNaN ( v ) ) { setChainArea_ ( chain , NumberUtils . TheNaN ) ; setChainPerimeter_ ( chain , NumberUtils . TheNaN ) ; } updateVertexToHalfEdgeConnection_ ( half_edge , true ) ; deleteEdgeImpl_ ( half_edge ) ; return n ; } | Use with care . |
26,201 | void deleteEdgesBreakFaces_ ( AttributeStreamOfInt32 edgesToDelete ) { for ( int i = 0 , n = edgesToDelete . size ( ) ; i < n ; i ++ ) { int half_edge = edgesToDelete . get ( i ) ; int chain = getHalfEdgeChain ( half_edge ) ; int halfEdgeTwin = getHalfEdgeTwin ( half_edge ) ; int chainTwin = getHalfEdgeChain ( halfEdgeTwin ) ; setChainHalfEdge_ ( chain , - 1 ) ; setChainHalfEdge_ ( chainTwin , - 1 ) ; updateVertexToHalfEdgeConnection_ ( half_edge , true ) ; deleteEdgeImpl_ ( half_edge ) ; } } | parentage information still . |
26,202 | double getChainArea ( int chain ) { int chainIndex = getChainIndex_ ( chain ) ; double v = m_chainAreas . read ( chainIndex ) ; if ( NumberUtils . isNaN ( v ) ) { updateChainAreaAndPerimeter_ ( chain ) ; v = m_chainAreas . read ( chainIndex ) ; } return v ; } | + Inf is returned for the universe chain . |
26,203 | double getChainPerimeter ( int chain ) { int chainIndex = getChainIndex_ ( chain ) ; double v = m_chainPerimeters . read ( chainIndex ) ; if ( NumberUtils . isNaN ( v ) ) { updateChainAreaAndPerimeter_ ( chain ) ; v = m_chainPerimeters . read ( chainIndex ) ; } return v ; } | universe chain . |
26,204 | int getChainUserIndex ( int chain , int index ) { int i = getChainIndex_ ( chain ) ; AttributeStreamOfInt32 stream = m_chainIndices . get ( index ) ; if ( stream . size ( ) <= i ) return - 1 ; return stream . read ( i ) ; } | Returns a user index value for the chain . |
26,205 | void setChainUserIndex ( int chain , int index , int value ) { int i = getChainIndex_ ( chain ) ; AttributeStreamOfInt32 stream = m_chainIndices . get ( index ) ; if ( stream . size ( ) <= i ) stream . resize ( m_chainData . size ( ) , - 1 ) ; stream . write ( i , value ) ; } | Sets a user index value for the chain . |
26,206 | int createUserIndexForChains ( ) { if ( m_chainIndices == null ) { m_chainIndices = new ArrayList < AttributeStreamOfInt32 > ( 3 ) ; } AttributeStreamOfInt32 new_stream = new AttributeStreamOfInt32 ( m_chainData . capacity ( ) , - 1 ) ; for ( int i = 0 , n = m_chainIndices . size ( ) ; i < n ; i ++ ) { if ( m_chainIndices . get ( i ) == null ) { m_chainIndices . set ( i , new_stream ) ; return i ; } } m_chainIndices . add ( new_stream ) ; return m_chainIndices . size ( ) - 1 ; } | Creates a new user index for the chains . The index values are set to - 1 . |
26,207 | int getHalfEdgeConnector ( int clusterFrom , int clusterTo ) { int first_edge = getClusterHalfEdge ( clusterFrom ) ; if ( first_edge == - 1 ) return - 1 ; int edge = first_edge ; int firstEdgeTo = - 1 ; int eTo = - 1 ; do { if ( getHalfEdgeTo ( edge ) == clusterTo ) return edge ; if ( firstEdgeTo == - 1 ) { firstEdgeTo = getClusterHalfEdge ( clusterTo ) ; if ( firstEdgeTo == - 1 ) return - 1 ; eTo = firstEdgeTo ; } if ( getHalfEdgeTo ( eTo ) == clusterFrom ) { edge = getHalfEdgeTwin ( eTo ) ; assert ( getHalfEdgeTo ( edge ) == clusterTo && getHalfEdgeOrigin ( edge ) == clusterFrom ) ; return edge ; } edge = getHalfEdgeNext ( getHalfEdgeTwin ( edge ) ) ; eTo = getHalfEdgeNext ( getHalfEdgeTwin ( eTo ) ) ; } while ( edge != first_edge && eTo != firstEdgeTo ) ; return - 1 ; } | Could be a slow operation when valency of each cluster is high . |
26,208 | void reset ( Envelope2D extent , int height ) { m_quad_tree_nodes . deleteAll ( false ) ; m_element_nodes . deleteAll ( false ) ; m_data . clear ( ) ; m_free_data . clear ( false ) ; reset_ ( extent , height ) ; } | Resets the Quad_tree_impl to the given extent and height . \ param extent The extent of the Quad_tree_impl . \ param height The max height of the Quad_tree_impl . |
26,209 | int insert ( int element , Envelope2D bounding_box ) { if ( m_root == - 1 ) create_root_ ( ) ; if ( m_b_store_duplicates ) { int success = insert_duplicates_ ( element , bounding_box , 0 , m_extent , m_root , false , - 1 ) ; if ( success != - 1 ) { if ( m_data_extent . isEmpty ( ) ) m_data_extent . setCoords ( bounding_box ) ; else m_data_extent . merge ( bounding_box ) ; } return success ; } int element_handle = insert_ ( element , bounding_box , 0 , m_extent , m_root , false , - 1 ) ; if ( element_handle != - 1 ) { if ( m_data_extent . isEmpty ( ) ) m_data_extent . setCoords ( bounding_box ) ; else m_data_extent . merge ( bounding_box ) ; } return element_handle ; } | Inserts the element and bounding_box into the Quad_tree_impl . Note that this will invalidate any active iterator on the Quad_tree_impl . Returns an Element_handle corresponding to the element and bounding_box . \ param element The element of the Geometry to be inserted . \ param bounding_box The bounding_box of the Geometry to be inserted . |
26,210 | int insert ( int element , Envelope2D bounding_box , int hint_index ) { if ( m_root == - 1 ) create_root_ ( ) ; if ( m_b_store_duplicates ) { int success = insert_duplicates_ ( element , bounding_box , 0 , m_extent , m_root , false , - 1 ) ; if ( success != - 1 ) { if ( m_data_extent . isEmpty ( ) ) m_data_extent . setCoords ( bounding_box ) ; else m_data_extent . merge ( bounding_box ) ; } return success ; } int quad_handle ; if ( hint_index == - 1 ) quad_handle = m_root ; else quad_handle = get_quad_ ( hint_index ) ; int quad_height = getHeight ( quad_handle ) ; Envelope2D quad_extent = getExtent ( quad_handle ) ; int element_handle = insert_ ( element , bounding_box , quad_height , quad_extent , quad_handle , false , - 1 ) ; if ( element_handle != - 1 ) { if ( m_data_extent . isEmpty ( ) ) m_data_extent . setCoords ( bounding_box ) ; else m_data_extent . merge ( bounding_box ) ; } return element_handle ; } | Inserts the element and bounding_box into the Quad_tree_impl at the given quad_handle . Note that this will invalidate any active iterator on the Quad_tree_impl . Returns an Element_handle corresponding to the element and bounding_box . \ param element The element of the Geometry to be inserted . \ param bounding_box The bounding_box of the Geometry to be inserted . \ param hint_index A handle used as a hint where to place the element . This can be a handle obtained from a previous insertion and is useful on data having strong locality such as segments of a Polygon . |
26,211 | void removeElement ( int element_handle ) { if ( m_b_store_duplicates ) throw new GeometryException ( "invalid call" ) ; int quad_handle = get_quad_ ( element_handle ) ; disconnect_element_handle_ ( element_handle ) ; free_element_and_box_node_ ( element_handle ) ; int q = quad_handle ; while ( q != - 1 ) { set_sub_tree_element_count_ ( q , get_sub_tree_element_count_ ( q ) - 1 ) ; int parent = get_parent_ ( q ) ; if ( get_sub_tree_element_count_ ( q ) == 0 ) { assert ( get_local_element_count_ ( q ) == 0 ) ; if ( q != m_root ) { int quadrant = get_quadrant_ ( q ) ; m_quad_tree_nodes . deleteElement ( q ) ; set_child_ ( parent , quadrant , - 1 ) ; } } q = parent ; } } | Removes the element and bounding_box at the given element_handle . Note that this will invalidate any active iterator on the Quad_tree_impl . \ param element_handle The handle corresponding to the element and bounding_box to be removed . |
26,212 | 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_parent_ ( q ) ; } while ( q != m_root ) ; int sz = quadrants . size ( ) ; assert ( sz == getHeight ( quad_handle ) ) ; for ( int i = 0 ; i < sz ; i ++ ) { int child = quadrants . getLast ( ) ; quadrants . removeLast ( ) ; if ( child == 0 ) { quad_extent . xmin = 0.5 * ( quad_extent . xmin + quad_extent . xmax ) ; quad_extent . ymin = 0.5 * ( quad_extent . ymin + quad_extent . ymax ) ; } else if ( child == 1 ) { quad_extent . xmax = 0.5 * ( quad_extent . xmin + quad_extent . xmax ) ; quad_extent . ymin = 0.5 * ( quad_extent . ymin + quad_extent . ymax ) ; } else if ( child == 2 ) { quad_extent . xmax = 0.5 * ( quad_extent . xmin + quad_extent . xmax ) ; quad_extent . ymax = 0.5 * ( quad_extent . ymin + quad_extent . ymax ) ; } else { quad_extent . xmin = 0.5 * ( quad_extent . xmin + quad_extent . xmax ) ; quad_extent . ymax = 0.5 * ( quad_extent . ymin + quad_extent . ymax ) ; } } return quad_extent ; } | Returns the extent of the quad at the given quad_handle . \ param quad_handle The handle corresponding to the quad . |
26,213 | 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 ) ; ArrayList < Envelope2D > extents_stack = new ArrayList < Envelope2D > ( 0 ) ; quads_stack . add ( m_root ) ; extents_stack . add ( new Envelope2D ( m_extent . xmin , m_extent . ymin , m_extent . xmax , m_extent . ymax ) ) ; Envelope2D [ ] child_extents = new Envelope2D [ 4 ] ; child_extents [ 0 ] = new Envelope2D ( ) ; child_extents [ 1 ] = new Envelope2D ( ) ; child_extents [ 2 ] = new Envelope2D ( ) ; child_extents [ 3 ] = new Envelope2D ( ) ; Envelope2D current_extent = new Envelope2D ( ) ; int intersection_count = 0 ; while ( quads_stack . size ( ) > 0 ) { boolean b_subdivide = false ; int current_quad_handle = quads_stack . getLast ( ) ; current_extent . setCoords ( extents_stack . get ( extents_stack . size ( ) - 1 ) ) ; quads_stack . removeLast ( ) ; extents_stack . remove ( extents_stack . size ( ) - 1 ) ; if ( query_inflated . contains ( current_extent ) ) { intersection_count += getSubTreeElementCount ( current_quad_handle ) ; if ( max_count > 0 && intersection_count >= max_count ) return max_count ; } else { if ( query_inflated . isIntersecting ( current_extent ) ) { for ( int element_handle = get_first_element_ ( current_quad_handle ) ; element_handle != - 1 ; element_handle = get_next_element_ ( element_handle ) ) { int data_handle = get_data_ ( element_handle ) ; Envelope2D env = get_bounding_box_value_ ( data_handle ) ; if ( env . isIntersecting ( query_inflated ) ) { intersection_count ++ ; if ( max_count > 0 && intersection_count >= max_count ) return max_count ; } } b_subdivide = getHeight ( current_quad_handle ) + 1 <= m_height ; } } if ( b_subdivide ) { set_child_extents_ ( current_extent , child_extents ) ; for ( int i = 0 ; i < 4 ; i ++ ) { int child_handle = get_child_ ( current_quad_handle , i ) ; if ( child_handle != - 1 && getSubTreeElementCount ( child_handle ) > 0 ) { boolean b_is_intersecting = query_inflated . isIntersecting ( child_extents [ i ] ) ; if ( b_is_intersecting ) { quads_stack . add ( child_handle ) ; extents_stack . add ( new Envelope2D ( child_extents [ i ] . xmin , child_extents [ i ] . ymin , child_extents [ i ] . xmax , child_extents [ i ] . ymax ) ) ; } } } } } return intersection_count ; } | Returns the number of elements in the quad tree that intersect the qiven query . Some elements may be duplicated if the quad tree stores duplicates . \ param query The Envelope_2D used for the query . \ param tolerance The tolerance used for the intersection tests . \ param max_count If the intersection count becomes greater than or equal to the max_count then max_count is returned . |
26,214 | static protected int isSimplePlanar ( Geometry geometry , SpatialReference spatialReference , boolean bForce , ProgressTracker progressTracker ) { assert ( false ) ; if ( geometry . isEmpty ( ) ) return 1 ; Geometry . Type gt = geometry . getType ( ) ; if ( gt == Geometry . Type . Point ) return 1 ; else if ( gt == Geometry . Type . Envelope ) { Envelope2D env2D = new Envelope2D ( ) ; geometry . queryEnvelope2D ( env2D ) ; boolean bReturnValue = ! env2D . isDegenerate ( InternalUtils . calculateToleranceFromGeometry ( spatialReference , geometry , false ) ) ; return bReturnValue ? 1 : 0 ; } else if ( Geometry . isSegment ( gt . value ( ) ) ) { throw GeometryException . GeometryInternalError ( ) ; } else if ( ! Geometry . isMultiVertex ( gt . value ( ) ) ) { throw GeometryException . GeometryInternalError ( ) ; } double tolerance = InternalUtils . calculateToleranceFromGeometry ( spatialReference , geometry , false ) ; double geomTolerance = 0 ; int isSimple = ( ( MultiVertexGeometryImpl ) geometry . _getImpl ( ) ) . getIsSimple ( tolerance ) ; int knownSimpleResult = bForce ? - 1 : isSimple ; if ( knownSimpleResult != - 1 ) return knownSimpleResult ; if ( knownSimpleResult == GeometryXSimple . Weak ) { assert ( tolerance <= geomTolerance ) ; tolerance = geomTolerance ; } OperatorSimplifyLocalHelper helper = new OperatorSimplifyLocalHelper ( geometry , spatialReference , knownSimpleResult , progressTracker , false ) ; knownSimpleResult = helper . isSimplePlanarImpl_ ( ) ; ( ( MultiVertexGeometryImpl ) geometry . _getImpl ( ) ) . setIsSimple ( knownSimpleResult , tolerance , false ) ; return knownSimpleResult ; } | The code is executed in the 2D plane only . Attributes are ignored . MultiPoint - check for clustering . Polyline - check for clustering and cracking . Polygon - check for clustering cracking absence of self - intersections and correct ring ordering . |
26,215 | private int edgeAngleCompare_ ( Edge edge1 , 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.0 ) ; if ( edge2 . getReversed ( ) ) v2 . negate ( ) ; int q1 = v1 . _getQuarter ( ) ; int q2 = v2 . _getQuarter ( ) ; if ( q2 == q1 ) { double cross = v1 . crossProduct ( v2 ) ; double crossError = 4 * NumberUtils . doubleEps ( ) * ( Math . abs ( v2 . x * v1 . y ) + Math . abs ( v2 . y * v1 . x ) ) ; if ( Math . abs ( cross ) <= crossError ) { cross -- ; cross ++ ; } assert ( Math . abs ( cross ) > crossError ) ; return cross < 0 ? 1 : ( cross > 0 ? - 1 : 0 ) ; } else { return q1 < q2 ? - 1 : 1 ; } } | compares angles between two edges |
26,216 | 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 ) env . merge ( pt . x , pt . y ) ; else env . mergeNE ( pt . x , pt . y ) ; b_first = false ; } return env ; } | Returns envelope of all coordinates . |
26,217 | 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 ( ) ; } | Adds a Geometry to the Edit_shape |
26,218 | 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 , ( MultiPoint ) srcGeometry ) ; return ; } throw GeometryException . GeometryInternalError ( ) ; } | Append a Geometry to the given geometry of the Edit_shape |
26,219 | 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 ) return newgeom ; m_vertices_mp . add ( multi_path , multi_path . getPathStart ( ipath ) , mp_impl . getPathEnd ( ipath ) ) ; m_xy_stream = ( AttributeStreamOfDbl ) m_vertices . getAttributeStreamRef ( VertexDescription . Semantics . POSITION ) ; int path = insertPath ( newgeom , - 1 ) ; setClosedPath ( path , mp_impl . isClosedPath ( ipath ) || as_polygon ) ; boolean b_some_segments = m_segments != null && mp_impl . getSegmentFlagsStreamRef ( ) != null ; for ( int ivertex = mp_impl . getPathStart ( ipath ) , iend = mp_impl . getPathEnd ( ipath ) ; ivertex < iend ; ivertex ++ ) { int vertex = insertVertex_ ( path , - 1 , null ) ; if ( b_some_segments ) { int vindex = getVertexIndex ( vertex ) ; if ( ( mp_impl . getSegmentFlags ( ivertex ) & SegmentFlags . enumLineSeg ) != 0 ) { setSegmentToIndex_ ( vindex , null ) ; } else { SegmentBuffer seg_buffer = new SegmentBuffer ( ) ; mp_impl . getSegment ( ivertex , seg_buffer , true ) ; setSegmentToIndex_ ( vindex , seg_buffer . get ( ) ) ; } } } return newgeom ; } | Adds a path |
26,220 | int removeGeometry ( int geometry ) { for ( int path = getFirstPath ( geometry ) ; path != - 1 ; path = removePath ( path ) ) { } int prev = getPrevGeometry ( geometry ) ; int next = getNextGeometry ( geometry ) ; if ( prev != - 1 ) setNextGeometry_ ( prev , next ) ; else { m_first_geometry = next ; } if ( next != - 1 ) setPrevGeometry_ ( next , prev ) ; else { m_last_geometry = prev ; } freeGeometry_ ( geometry ) ; return next ; } | Deletes existing geometry from the edit shape and returns the next one . |
26,221 | 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 ( description ) ; m_vertex_description = m_vertices_mp . getDescription ( ) ; m_b_has_attributes = m_vertex_description . getAttributeCount ( ) > 1 ; if ( m_first_geometry == - 1 ) { m_first_geometry = newgeom ; m_last_geometry = newgeom ; } else { setPrevGeometry_ ( newgeom , m_last_geometry ) ; setNextGeometry_ ( m_last_geometry , newgeom ) ; m_last_geometry = newgeom ; } return newgeom ; } | create a new empty geometry of the given type and attribute set . |
26,222 | 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 ) ; } | Sets value to the given user index on a geometry . |
26,223 | 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 ; } | Returns the value of the given user index of a geometry |
26,224 | int createGeometryUserIndex ( ) { if ( m_geometry_indices == null ) m_geometry_indices = new ArrayList < AttributeStreamOfInt32 > ( 4 ) ; for ( int i = 0 ; i < m_geometry_indices . size ( ) ; i ++ ) { if ( m_geometry_indices . get ( i ) == null ) { m_geometry_indices . set ( i , ( AttributeStreamOfInt32 ) AttributeStreamBase . createIndexStream ( 0 ) ) ; return i ; } } m_geometry_indices . add ( ( AttributeStreamOfInt32 ) AttributeStreamBase . createIndexStream ( 0 ) ) ; return m_geometry_indices . size ( ) - 1 ; } | stores - 1 for that geometry . |
26,225 | 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 = getFirstPath ( geometry ) ; path != - 1 ; ) { int path_size = getPathSize ( path ) ; if ( b_polygon ? path_size < 3 : path_size < 2 ) return true ; int vertex = getFirstVertex ( path ) ; for ( int index = 0 ; index < path_size ; index ++ ) { int next = getNextVertex ( vertex ) ; if ( next == - 1 ) break ; int vindex = getVertexIndex ( vertex ) ; Segment seg = getSegmentFromIndex_ ( vindex ) ; double length = 0 ; if ( seg != null ) { length = seg . calculateLength2D ( ) ; } else { int vindex_next = getVertexIndex ( next ) ; length = m_vertices . _getShortestDistance ( vindex , vindex_next ) ; } if ( length <= tolerance ) return true ; vertex = next ; } path = getNextPath ( path ) ; } } return false ; } | Checks if there are degenerate segments in any of multipath geometries |
26,226 | 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_vertex ) ; Segment seg = getSegmentFromIndex_ ( vindex ) ; double seg_length = seg == null ? m_vertices . _getShortestDistance ( vindex , vindex_next ) : seg . calculateLength2D ( ) ; double told = 0.0 ; for ( int i = 0 ; i < split_count ; i ++ ) { double t = split_scalars [ i ] ; if ( told < t && t < 1.0 ) { double f = t ; if ( seg != null ) { f = seg_length > 0 ? seg . _calculateSubLength ( t ) / seg_length : 0.0 ; } m_vertices . _interpolateTwoVertices ( vindex , vindex_next , f , getHelperPoint_ ( ) ) ; int inserted_vertex = insertVertex_ ( getPathFromVertex ( origin_vertex ) , next_vertex , getHelperPoint_ ( ) ) ; actual_splits ++ ; if ( seg != null ) { Segment subseg = seg . cut ( told , t ) ; int prev_vertex = getPrevVertex ( inserted_vertex ) ; int vindex_prev = getVertexIndex ( prev_vertex ) ; setSegmentToIndex_ ( vindex_prev , subseg ) ; setXY ( inserted_vertex , subseg . getEndXY ( ) ) ; if ( i == split_count - 1 || split_scalars [ i + 1 ] == 1.0 ) { Segment subseg_end = seg . cut ( t , 1.0 ) ; setSegmentToIndex_ ( vindex_prev , subseg_end ) ; } } } } return actual_splits ; } | happend ) . |
26,227 | int createUserIndex ( ) { if ( m_indices == null ) m_indices = new ArrayList < AttributeStreamOfInt32 > ( 0 ) ; for ( int i = 0 ; i < m_indices . size ( ) ; i ++ ) { if ( m_indices . get ( i ) == null ) { m_indices . set ( i , ( AttributeStreamOfInt32 ) AttributeStreamBase . createIndexStream ( 0 , - 1 ) ) ; return i ; } } m_indices . add ( ( AttributeStreamOfInt32 ) AttributeStreamBase . createIndexStream ( 0 , - 1 ) ) ; return m_indices . size ( ) - 1 ; } | store an integer user value on the vertex . |
26,228 | Segment getSegment ( int vertex ) { if ( m_segments != null ) { int vindex = getVertexIndex ( vertex ) ; return m_segments . get ( vindex ) ; } return null ; } | if it is a Line . |
26,229 | 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 ( ) ; queryPoint ( vertex , pt ) ; line . setStart ( pt ) ; queryPoint ( next , pt ) ; line . setEnd ( pt ) ; } return true ; } | Can be used together with get_segment . |
26,230 | 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 ( before_path != - 1 ) setPrevPath_ ( before_path , newpath ) ; setNextPath_ ( newpath , before_path ) ; setPrevPath_ ( newpath , prev ) ; if ( prev != - 1 ) setNextPath_ ( prev , newpath ) ; else setFirstPath_ ( geometry , newpath ) ; if ( before_path == - 1 ) setLastPath_ ( geometry , newpath ) ; setGeometryPathCount_ ( geometry , getPathCount ( geometry ) + 1 ) ; return newpath ; } | path at the end . |
26,231 | 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 ) ; } clearPath ( path ) ; setGeometryPathCount_ ( geometry , getPathCount ( geometry ) - 1 ) ; freePath_ ( path ) ; return next ; } | Removes a path gets rid of all its vertices and returns the next one |
26,232 | void clearPath ( int path ) { int first_vertex = getFirstVertex ( path ) ; if ( first_vertex != - 1 ) { int vertex = first_vertex ; for ( int i = 0 , n = getPathSize ( path ) ; i < n ; i ++ ) { int v = vertex ; vertex = getNextVertex ( vertex ) ; freeVertex_ ( v ) ; } int geometry = getGeometryFromPath ( path ) ; setGeometryVertexCount_ ( geometry , getPointCount ( geometry ) - getPathSize ( path ) ) ; } setPathSize_ ( path , 0 ) ; } | Clears all vertices from the path |
26,233 | 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 ) ; i < n ; i ++ , vertex = getNextVertex ( vertex ) ) { Segment seg = getSegment ( vertex ) ; if ( seg == null ) { if ( ! queryLineConnector ( vertex , line ) ) continue ; seg = line ; } double a = seg . _calculateArea2DHelper ( pt0 . x , pt0 . y ) ; area += a ; } setRingAreaValid_ ( path , true ) ; m_path_areas . set ( getPathIndex_ ( path ) , area ) ; return area ; } | Returns the ring area |
26,234 | 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 ) ; } | Sets value to the given user index on a path . |
26,235 | 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 ; } | Returns the value of the given user index of a path |
26,236 | int createPathUserIndex ( ) { if ( m_pathindices == null ) m_pathindices = new ArrayList < AttributeStreamOfInt32 > ( 0 ) ; for ( int i = 0 ; i < m_pathindices . size ( ) ; i ++ ) { if ( m_pathindices . get ( i ) == null ) { m_pathindices . set ( i , ( AttributeStreamOfInt32 ) ( AttributeStreamBase . createIndexStream ( 0 ) ) ) ; return i ; } } m_pathindices . add ( ( AttributeStreamOfInt32 ) ( AttributeStreamBase . createIndexStream ( 0 ) ) ) ; return ( int ) ( m_pathindices . size ( ) - 1 ) ; } | index allows to store an integer user value on the path . |
26,237 | 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 == - 1 ) { setFirstPath_ ( geom_src , next ) ; } else { setNextPath_ ( prev , next ) ; } if ( next == - 1 ) { setLastPath_ ( geom_src , prev ) ; } else { setPrevPath_ ( next , prev ) ; } setGeometryVertexCount_ ( geom_src , getPointCount ( geom_src ) - getPathSize ( path_to_move ) ) ; setGeometryPathCount_ ( geom_src , getPathCount ( geom_src ) - 1 ) ; if ( before_path == - 1 ) prev = getLastPath ( geom ) ; else prev = getPrevPath ( before_path ) ; setPrevPath_ ( path_to_move , prev ) ; setNextPath_ ( path_to_move , before_path ) ; if ( before_path == - 1 ) setLastPath_ ( geom , path_to_move ) ; else setPrevPath_ ( before_path , path_to_move ) ; if ( prev == - 1 ) setFirstPath_ ( geom , path_to_move ) ; else setNextPath_ ( prev , path_to_move ) ; setGeometryVertexCount_ ( geom , getPointCount ( geom ) + getPathSize ( path_to_move ) ) ; setGeometryPathCount_ ( geom , getPathCount ( geom ) + 1 ) ; setPathGeometry_ ( path_to_move , geom ) ; } | before_path can be - 1 then the path is moved to the end of the dst_geom . |
26,238 | int addVertex ( int path , int vertex ) { m_vertices . getPointByVal ( getVertexIndex ( vertex ) , getHelperPoint_ ( ) ) ; return insertVertex_ ( path , - 1 , getHelperPoint_ ( ) ) ; } | Returns new vertex handle . |
26,239 | 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 , path_size > 1 ? next : - 1 ) ; } if ( next != - 1 ) setPrevVertex_ ( next , prev ) ; if ( vertex == getLastVertex ( path ) ) { setLastVertex_ ( path , path_size > 1 ? prev : - 1 ) ; } if ( prev != - 1 && next != - 1 ) { int vindex_prev = getVertexIndex ( prev ) ; int vindex_next = getVertexIndex ( next ) ; if ( b_left_segment ) { Segment seg = getSegmentFromIndex_ ( vindex_prev ) ; if ( seg != null ) { Point2D pt = new Point2D ( ) ; m_vertices . getXY ( vindex_next , pt ) ; seg . setEndXY ( pt ) ; } } else { int vindex_erased = getVertexIndex ( vertex ) ; Segment seg = getSegmentFromIndex_ ( vindex_erased ) ; setSegmentToIndex_ ( vindex_prev , seg ) ; if ( seg != null ) { Point2D pt = m_vertices . getXY ( vindex_prev ) ; seg . setStartXY ( pt ) ; } } } setPathSize_ ( path , path_size - 1 ) ; int geometry = getGeometryFromPath ( path ) ; setGeometryVertexCount_ ( geometry , getPointCount ( geometry ) - 1 ) ; freeVertex_ ( vertex ) ; return next ; } | reconnect . Returns next vertex after erased one . |
26,240 | 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 ) ; } } } } | Applies affine transformation |
26,241 | public int insert ( int element , Envelope2D boundingBox , int hintIndex ) { return m_impl . insert ( element , boundingBox , hintIndex ) ; } | Inserts the element and bounding_box into the QuadTree at the given quad_handle . Note that a copy will me made of the input bounding_box . Note that this will invalidate any active iterator on the QuadTree . Returns an Element_handle corresponding to the element and bounding_box . \ param element The element of the Geometry to be inserted . \ param bounding_box The bounding_box of the Geometry to be inserted . \ param hint_index A handle used as a hint where to place the element . This can be a handle obtained from a previous insertion and is useful on data having strong locality such as segments of a Polygon . |
26,242 | public int getIntersectionCount ( Envelope2D query , double tolerance , int maxCount ) { return m_impl . getIntersectionCount ( query , tolerance , maxCount ) ; } | Returns the number of elements in the quad tree that intersect the qiven query . Some elements may be duplicated if the quad tree stores duplicates . \ param query The Envelope2D used for the query . \ param tolerance The tolerance used for the intersection tests . \ param max_count If the intersection count becomes greater than or equal to the max_count then max_count is returned . |
26,243 | public QuadTreeIterator getIterator ( Geometry query , double tolerance ) { QuadTreeImpl . QuadTreeIteratorImpl iterator = m_impl . getIterator ( query , tolerance ) ; return new QuadTreeIterator ( iterator , false ) ; } | Gets an iterator on the QuadTree . The query will be the Envelope2D that bounds the input Geometry . To reuse the existing iterator on the same QuadTree but with a new query use the reset_iterator function on the QuadTree_iterator . \ param query The Geometry used for the query . If the Geometry is a Line segment then the query will be the segment . Otherwise the query will be the Envelope2D bounding the Geometry . \ param tolerance The tolerance used for the intersection tests . |
26,244 | public QuadTreeIterator getIterator ( ) { QuadTreeImpl . QuadTreeIteratorImpl iterator = m_impl . getIterator ( ) ; return new QuadTreeIterator ( iterator , false ) ; } | Gets an iterator on the QuadTree . |
26,245 | 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 . getSortedIterator ( query , tolerance ) ; return new QuadTreeIterator ( iterator , true ) ; } } | Gets an iterator on the QuadTree . The query will be the Envelope2D that bounds the input Geometry . To reuse the existing iterator on the same QuadTree but with a new query use the reset_iterator function on the QuadTree_iterator . \ param query The Geometry used for the query . If the Geometry is a Line segment then the query will be the segment . Otherwise the query will be the Envelope2D bounding the Geometry . \ param tolerance The tolerance used for the intersection tests . \ param bSorted Put true to iterate the quad tree in the order of the Element_types . |
26,246 | 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 ( iterator , true ) ; } } | Gets an iterator on the QuadTree . \ param bSorted Put true to iterate the quad tree in the order of the Element_types . |
26,247 | public Point2D getCoord2D ( double t ) { Point2D pt = new Point2D ( ) ; getCoord2D ( t , pt ) ; return pt ; } | Returns the coordinate of the point on this segment for the given parameter value . |
26,248 | public void startPath ( double x , double y ) { Point2D endPoint = new Point2D ( ) ; endPoint . x = x ; endPoint . y = y ; startPath ( endPoint ) ; } | Starts a new Path at the Point . |
26,249 | 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 - 2 , m_curveParamwritePoint ) ; m_curveParamwritePoint += 6 ; int curveIndex = m_curveParamwritePoint ; m_segmentParams . write ( curveIndex , controlPoint1 . x ) ; m_segmentParams . write ( curveIndex + 1 , controlPoint1 . y ) ; z = 0 ; m_segmentParams . write ( curveIndex + 2 , z ) ; m_segmentParams . write ( curveIndex + 3 , controlPoint2 . x ) ; m_segmentParams . write ( curveIndex + 4 , controlPoint2 . y ) ; z = 0 ; m_segmentParams . write ( curveIndex + 5 , z ) ; _finishBezierTo ( ) ; } | adds a Cubic Bezier Segment to the current Path . The Bezier Segment connects the current last Point and the given endPoint . |
26,250 | public void openAllPathsAndDuplicateStartVertex ( ) { _touch ( ) ; if ( m_bPolygon ) throw GeometryException . GeometryInternalError ( ) ; if ( m_pathFlags == null ) throw GeometryException . GeometryInternalError ( ) ; _verifyAllStreams ( ) ; int closedPathCount = 0 ; int pathCount = getPathCount ( ) ; for ( int i = 0 ; i < pathCount ; i ++ ) { if ( m_pathFlags . read ( i ) == ( byte ) PathFlags . enumClosed ) { closedPathCount ++ ; } } for ( int iattr = 0 , nattr = m_description . getAttributeCount ( ) ; iattr < nattr ; iattr ++ ) { if ( m_vertexAttributes [ iattr ] != null ) { int semantics = m_description . _getSemanticsImpl ( iattr ) ; int comp = VertexDescription . getComponentCount ( semantics ) ; int newSize = comp * ( m_pointCount + closedPathCount ) ; m_vertexAttributes [ iattr ] . resize ( newSize ) ; int offset = closedPathCount ; int ipath = pathCount ; for ( int i = m_pointCount - 1 ; i >= 0 ; i -- ) { if ( i + 1 == m_paths . read ( ipath ) ) { ipath -- ; if ( m_pathFlags . read ( ipath ) == ( byte ) PathFlags . enumClosed ) { int istart = m_paths . read ( ipath ) ; for ( int c = 0 ; c < comp ; c ++ ) { double v = m_vertexAttributes [ iattr ] . readAsDbl ( comp * istart + c ) ; m_vertexAttributes [ iattr ] . writeAsDbl ( comp * ( offset + i ) + c , v ) ; } if ( -- offset == 0 ) break ; } } for ( int c = 0 ; c < comp ; c ++ ) { double v = m_vertexAttributes [ iattr ] . readAsDbl ( comp * i + c ) ; m_vertexAttributes [ iattr ] . writeAsDbl ( comp * ( offset + i ) + c , v ) ; } } } } int offset = closedPathCount ; for ( int ipath = pathCount ; ipath > 0 ; ipath -- ) { int iend = m_paths . read ( ipath ) ; m_paths . write ( ipath , iend + offset ) ; if ( m_pathFlags . read ( ipath - 1 ) == ( byte ) PathFlags . enumClosed ) { m_pathFlags . clearBits ( ipath - 1 , ( byte ) PathFlags . enumClosed ) ; if ( -- offset == 0 ) { break ; } } } m_pointCount += closedPathCount ; } | Major Changes on 16th of January |
26,251 | 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 | PathFlags . enumClosed ) ) ; } } | Closes all open curves by adding an implicit line segment from the end point to the start point . |
26,252 | 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 ( pathIndex ) ; m_pathFlags . write ( pathIndex , ( byte ) ( pf | PathFlags . enumClosed | PathFlags . enumHasNonlinearSegments ) ) ; _initSegmentData ( 6 ) ; byte oldType = m_segmentFlags . read ( ( byte ) ( ( m_pointCount - 1 ) & SegmentFlags . enumSegmentMask ) ) ; m_segmentFlags . write ( m_pointCount - 1 , ( byte ) ( SegmentFlags . enumBezierSeg ) ) ; int curveIndex = m_curveParamwritePoint ; if ( getSegmentDataSize ( oldType ) < getSegmentDataSize ( ( byte ) SegmentFlags . enumBezierSeg ) ) { m_segmentParamIndex . write ( m_pointCount - 1 , m_curveParamwritePoint ) ; m_curveParamwritePoint += 6 ; } else { curveIndex = m_segmentParamIndex . read ( m_pointCount - 1 ) ; } double z ; m_segmentParams . write ( curveIndex , controlPoint1 . x ) ; m_segmentParams . write ( curveIndex + 1 , controlPoint1 . y ) ; z = 0 ; m_segmentParams . write ( curveIndex + 2 , z ) ; m_segmentParams . write ( curveIndex + 3 , controlPoint2 . x ) ; m_segmentParams . write ( curveIndex + 4 , controlPoint2 . y ) ; z = 0 ; m_segmentParams . write ( curveIndex + 5 , z ) ; } | Closes last path of the MultiPathImpl with the Bezier Segment . |
26,253 | 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 ] ; } if ( ( dimensionMask & 2 ) != 0 ) { if ( res_vec [ inext ] == null ) res_vec [ inext ] = new Polyline ( descr ) ; inext ++ ; } else { for ( int i = inext ; i < res_vec . length - 1 ; i ++ ) res_vec [ i ] = res_vec [ i + 1 ] ; } if ( ( dimensionMask & 4 ) != 0 ) { if ( res_vec [ inext ] == null ) res_vec [ inext ] = new Polygon ( descr ) ; inext ++ ; } else { for ( int i = inext ; i < res_vec . length - 1 ; i ++ ) res_vec [ i ] = res_vec [ i + 1 ] ; } if ( inext != 3 ) { Geometry [ ] r = new Geometry [ inext ] ; for ( int i = 0 ; i < inext ; i ++ ) r [ i ] = res_vec [ i ] ; return new SimpleGeometryCursor ( r ) ; } else { return new SimpleGeometryCursor ( res_vec ) ; } } | as indicated with the dimensionMask |
26,254 | 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 { } } return null ; } | Returns a cached edge for the given value . May return NULL . |
26,255 | 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 ) { m_simple_edges_recycle . add ( se ) ; m_simple_edges_cache . set ( ind , null ) ; } else { } } | Removes cached edge from the cache for the given value . |
26,256 | 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 ( ) ) { m_simple_edges_buffer . add ( new SimpleEdge ( ) ) ; se = m_simple_edges_buffer . get ( m_simple_edges_buffer . size ( ) - 1 ) ; } else { se = m_simple_edges_recycle . get ( m_simple_edges_recycle . size ( ) - 1 ) ; m_simple_edges_recycle . remove ( m_simple_edges_recycle . size ( ) - 1 ) ; } se . m_value = value ; m_simple_edges_cache . set ( ind , se ) ; return se ; } else { assert ( se . m_value != value ) ; } return null ; } | Creates a cached edge . May fail and return NULL . |
26,257 | 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_2 . getStartXY ( ) ; Point2D end2 = seg_2 . getEndXY ( ) ; Point2D ptSweep = new Point2D ( ) ; ptSweep . setCoords ( m_sweep_x , m_sweep_y ) ; if ( start_1 . isEqual ( start2 ) && m_sweep_y == start_1 . y ) { assert ( start_1 . compare ( end1 ) < 0 && start2 . compare ( end2 ) < 0 ) ; if ( end1 . compare ( end2 ) < 0 ) ptSweep . setCoords ( end1 ) ; else ptSweep . setCoords ( end2 ) ; } else if ( start_1 . isEqual ( end2 ) && m_sweep_y == start_1 . y ) { assert ( start_1 . compare ( end1 ) < 0 && start2 . compare ( end2 ) > 0 ) ; if ( end1 . compare ( start2 ) < 0 ) ptSweep . setCoords ( end1 ) ; else ptSweep . setCoords ( start2 ) ; } else if ( start2 . isEqual ( end1 ) && m_sweep_y == start2 . y ) { assert ( end1 . compare ( start_1 ) < 0 && start2 . compare ( end2 ) < 0 ) ; if ( start_1 . compare ( end2 ) < 0 ) ptSweep . setCoords ( start_1 ) ; else ptSweep . setCoords ( end2 ) ; } else if ( end1 . isEqual ( end2 ) && m_sweep_y == end1 . y ) { assert ( start_1 . compare ( end1 ) > 0 && start2 . compare ( end2 ) > 0 ) ; if ( start_1 . compare ( start2 ) < 0 ) ptSweep . setCoords ( start_1 ) ; else ptSweep . setCoords ( start2 ) ; } double xleft = seg_1 . intersectionOfYMonotonicWithAxisX ( ptSweep . y , ptSweep . x ) ; double xright = seg_2 . intersectionOfYMonotonicWithAxisX ( ptSweep . y , ptSweep . x ) ; assert ( xleft != xright ) ; return xleft < xright ? - 1 : 1 ; } | is set . |
26,258 | void setSweepY ( double y , double 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 ; } | Sets new sweep line position . |
26,259 | 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 ) ; } } | Sets the envelope from the array of points . The envelope will be set to empty if the array is null . |
26,260 | 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 ; } | Merges a point with this envelope without checking if the envelope is empty . Use with care . |
26,261 | public boolean isIntersectingNE ( Envelope2D other ) { return ( ( xmin <= other . xmin ) ? xmax >= other . xmin : other . xmax >= xmin ) && ( ( ymin <= other . ymin ) ? ymax >= other . ymin : other . ymax >= ymin ) ; } | Checks if this envelope intersects the other assuming neither one is empty . |
26,262 | 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 ( ) ; } } | Queries a corner of the envelope . |
26,263 | 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 corners [ 1 ] = new Point2D ( xmin , ymax ) ; if ( corners [ 2 ] != null ) corners [ 2 ] . setCoords ( xmax , ymax ) ; else corners [ 2 ] = new Point2D ( xmax , ymax ) ; if ( corners [ 3 ] != null ) corners [ 3 ] . setCoords ( xmax , ymin ) ; else corners [ 3 ] = new Point2D ( xmax , ymin ) ; } | Queries corners into a given array . The array length must be at least 4 . Starts from the lower left corner and goes clockwise . |
26,264 | public void move ( double dx , double dy ) { if ( isEmpty ( ) ) return ; xmin += dx ; ymin += dy ; xmax += dx ; ymax += dy ; } | Moves the Envelope by given distance . |
26,265 | 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 == ymin ) return height * 2.0 + width + xmax - pt . x ; return _boundaryDistance ( _snapToBoundary ( pt ) ) ; } | function ) . |
26,266 | 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 ; } | returns 0 .. 3 depending on which side pt lies . |
26,267 | 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 ] ; int modified = 0 ; Point2D delta = new Point2D ( p1 . x - p0 . x , p1 . y - p0 . y ) ; if ( delta . x == 0.0 && delta . y == 0.0 ) { segParams [ 0 ] = 0.0 ; segParams [ 1 ] = 0.0 ; return contains ( p0 ) ? 4 : 0 ; } segParams [ 0 ] = ( ( lineExtension & 1 ) != 0 ) ? NumberUtils . negativeInf ( ) : 0.0 ; segParams [ 1 ] = ( ( lineExtension & 2 ) != 0 ) ? NumberUtils . positiveInf ( ) : 1.0 ; tOld [ 0 ] = segParams [ 0 ] ; tOld [ 1 ] = segParams [ 1 ] ; if ( clipLineAuxiliary ( delta . x , xmin - p0 . x , segParams ) && clipLineAuxiliary ( - delta . x , p0 . x - xmax , segParams ) && clipLineAuxiliary ( delta . y , ymin - p0 . y , segParams ) && clipLineAuxiliary ( - delta . y , p0 . y - ymax , segParams ) ) { if ( segParams [ 1 ] < tOld [ 1 ] ) { p1 . scaleAdd ( segParams [ 1 ] , delta , p0 ) ; _snapToBoundary ( p1 ) ; modified |= 2 ; if ( boundaryDistances != null ) boundaryDistances [ 1 ] = _boundaryDistance ( p1 ) ; } if ( segParams [ 0 ] > tOld [ 0 ] ) { p0 . scaleAdd ( segParams [ 0 ] , delta , p0 ) ; _snapToBoundary ( p0 ) ; modified |= 1 ; if ( boundaryDistances != null ) boundaryDistances [ 0 ] = _boundaryDistance ( p0 ) ; } } return modified ; } | 4 - the segment is complitely inside of the clipping window |
26,268 | 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 < 4 ; j ++ ) { double d = Point2D . sqrDistance ( points [ i ] , points_o [ j ] ) ; if ( d > dist ) { dist = d ; } } } return dist ; } | Returns squared max distance between two bounding boxes . This is furthest distance between points on the two envelopes . |
26,269 | 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 ; } | Calculates minimum squared distance from this envelope to the point . Returns 0 for empty envelopes . |
26,270 | public void setEnvelope ( Envelope env ) { if ( ! m_description . equals ( env . getDescription ( ) ) ) throw new IllegalArgumentException ( ) ; m_envelope = ( Envelope ) env . createInstance ( ) ; env . copyTo ( m_envelope ) ; _setDirtyFlag ( DirtyFlags . DirtyIntervals , false ) ; } | Sets the envelope of the Geometry . The Envelope description must match that of the Geometry . |
26,271 | 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 AttributeStreamBase [ nattrib ] ; for ( int i = 0 ; i < nattrib ; i ++ ) { if ( m_vertexAttributes [ i ] != null ) { int ncomps = VertexDescription . getComponentCount ( m_description . _getSemanticsImpl ( i ) ) ; cloneAttributes [ i ] = m_vertexAttributes [ i ] . restrictedClone ( getPointCount ( ) * ncomps ) ; } } } if ( m_envelope != null ) { dst . m_envelope = ( Envelope ) m_envelope . createInstance ( ) ; m_envelope . copyTo ( dst . m_envelope ) ; } else dst . m_envelope = null ; dst . m_pointCount = m_pointCount ; dst . m_flagsMask = m_flagsMask ; dst . m_vertexAttributes = cloneAttributes ; try { _copyToImpl ( dst ) ; } catch ( Exception ex ) { dst . setEmpty ( ) ; throw new RuntimeException ( ex ) ; } } | Does not check geometry type . Used to copy Polygon to Polyline |
26,272 | public void notifyModified ( int flags ) { if ( flags == DirtyFlags . DirtyAll ) { m_reservedPointCount = - 1 ; _notifyModifiedAllImpl ( ) ; } m_flagsMask |= flags ; _clearAccelerators ( ) ; _touch ( ) ; } | Notifies the Geometry of changes made to the vertices so that it could reset cached structures . |
26,273 | 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 ) ; } } | \ internal Updates x y intervals . |
26,274 | 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 - 1 ; } | and valid ring ordering ) |
26,275 | 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 . m_bAllowCoincident = allowCoincident ; if ( cracker . needsCrackingImpl_ ( ) ) { if ( result != null ) result . Assign ( cracker . m_non_simple_result ) ; return true ; } Transformation2D transform = new Transformation2D ( ) ; transform . setSwapCoordinates ( ) ; shape . applyTransformation ( transform ) ; cracker = new Cracker ( progress_tracker ) ; cracker . m_shape = shape ; cracker . m_tolerance = tolerance ; cracker . m_bAllowCoincident = allowCoincident ; boolean b_res = cracker . needsCrackingImpl_ ( ) ; transform . setSwapCoordinates ( ) ; shape . applyTransformation ( transform ) ; if ( b_res ) { if ( result != null ) result . Assign ( cracker . m_non_simple_result ) ; return true ; } return false ; } | Used for IsSimple . |
26,276 | public boolean isSimpleRelaxed ( ) { OperatorSimplify op = ( OperatorSimplify ) OperatorFactoryLocal . getInstance ( ) . getOperator ( Operator . Type . Simplify ) ; return op . isSimpleAsFeature ( getEsriGeometry ( ) , esriSR , true , null , null ) ; } | Extension method - checks if geometry is simple for Geodatabase . |
26,277 | public OGCGeometry makeSimpleRelaxed ( boolean forceProcessing ) { OperatorSimplify op = ( OperatorSimplify ) OperatorFactoryLocal . getInstance ( ) . getOperator ( Operator . Type . Simplify ) ; return OGCGeometry . createFromEsriGeometry ( op . execute ( getEsriGeometry ( ) , esriSR , forceProcessing , null ) , esriSR ) ; } | Makes a simple geometry for Geodatabase . |
26,278 | private OGCGeometry simplifyBunch_ ( GeometryCursor gc ) { MultiPoint dstMultiPoint = null ; ArrayList < Geometry > dstPolylines = new ArrayList < Geometry > ( ) ; ArrayList < Geometry > dstPolygons = new ArrayList < Geometry > ( ) ; for ( com . esri . core . geometry . Geometry g = gc . next ( ) ; g != null ; g = gc . next ( ) ) { switch ( g . getType ( ) ) { case Point : if ( dstMultiPoint == null ) dstMultiPoint = new MultiPoint ( ) ; dstMultiPoint . add ( ( Point ) g ) ; break ; case MultiPoint : if ( dstMultiPoint == null ) dstMultiPoint = new MultiPoint ( ) ; dstMultiPoint . add ( ( MultiPoint ) g , 0 , - 1 ) ; break ; case Polyline : dstPolylines . add ( ( Polyline ) g . copy ( ) ) ; break ; case Polygon : dstPolygons . add ( ( Polygon ) g . copy ( ) ) ; break ; default : throw new UnsupportedOperationException ( ) ; } } ArrayList < Geometry > result = new ArrayList < Geometry > ( 3 ) ; if ( dstMultiPoint != null ) { Geometry resMP = OperatorSimplifyOGC . local ( ) . execute ( dstMultiPoint , esriSR , true , null ) ; result . add ( resMP ) ; } if ( dstPolylines . size ( ) > 0 ) { if ( dstPolylines . size ( ) == 1 ) { Geometry resMP = OperatorSimplifyOGC . local ( ) . execute ( dstPolylines . get ( 0 ) , esriSR , true , null ) ; result . add ( resMP ) ; } else { GeometryCursor res = OperatorUnion . local ( ) . execute ( new SimpleGeometryCursor ( dstPolylines ) , esriSR , null ) ; Geometry resPolyline = res . next ( ) ; Geometry resMP = OperatorSimplifyOGC . local ( ) . execute ( resPolyline , esriSR , true , null ) ; result . add ( resMP ) ; } } if ( dstPolygons . size ( ) > 0 ) { if ( dstPolygons . size ( ) == 1 ) { Geometry resMP = OperatorSimplifyOGC . local ( ) . execute ( dstPolygons . get ( 0 ) , esriSR , true , null ) ; result . add ( resMP ) ; } else { GeometryCursor res = OperatorUnion . local ( ) . execute ( new SimpleGeometryCursor ( dstPolygons ) , esriSR , null ) ; Geometry resPolygon = res . next ( ) ; Geometry resMP = OperatorSimplifyOGC . local ( ) . execute ( resPolygon , esriSR , true , null ) ; result . add ( resMP ) ; } } return OGCGeometry . createFromEsriCursor ( new SimpleGeometryCursor ( result ) , esriSR ) ; } | it produces a single OGCGeometry . |
26,279 | public static OGCGeometry createFromEsriCursor ( GeometryCursor gc , SpatialReference sr ) { return createFromEsriCursor ( gc , sr , false ) ; } | Create an OGCGeometry instance from the GeometryCursor . |
26,280 | 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 , false ) ; m_complications = filtered == 1 ; bresult |= filtered == 1 ; } if ( m_vertex_cluster_index != - 1 ) { m_shape . removeUserIndex ( m_vertex_cluster_index ) ; m_vertex_cluster_index = - 1 ; } m_shape = null ; return bresult ; } | Does one pass sweep vertically |
26,281 | 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 ; } | Creates a new unattached edge with the given origin . |
26,282 | void mergeClusters_ ( int cluster_1 , int cluster2 ) { int eventQnode = getClusterEventQNode ( cluster2 ) ; if ( eventQnode != - 1 ) { m_event_q . deleteNode ( eventQnode , - 1 ) ; setClusterEventQNode_ ( cluster2 , - 1 ) ; } int firstEdge1 = getClusterFirstEdge ( cluster_1 ) ; int firstEdge2 = getClusterFirstEdge ( cluster2 ) ; if ( firstEdge2 != - 1 ) { int edge2 = firstEdge2 ; int lastEdge = firstEdge2 ; boolean bForceContinue = false ; do { bForceContinue = false ; int end = getEdgeEnd ( edge2 , cluster2 ) ; int nextEdge2 = getNextEdgeEx ( edge2 , end ) ; if ( getEdgeCluster ( edge2 , ( end + 1 ) & 1 ) == cluster_1 ) { disconnectEdge_ ( edge2 ) ; int edgeOrigins2 = getEdgeOriginVertices ( edge2 ) ; m_edge_vertices . deleteList ( edgeOrigins2 ) ; deleteEdge_ ( edge2 ) ; if ( edge2 == nextEdge2 ) { firstEdge2 = - 1 ; break ; } if ( firstEdge2 == edge2 ) { firstEdge2 = getClusterFirstEdge ( cluster2 ) ; lastEdge = nextEdge2 ; bForceContinue = true ; } } else { assert ( edge2 != getClusterFirstEdge ( cluster_1 ) ) ; } edge2 = nextEdge2 ; } while ( edge2 != lastEdge || bForceContinue ) ; if ( firstEdge2 != - 1 ) { do { int end = getEdgeEnd ( edge2 , cluster2 ) ; int nextEdge2 = getNextEdgeEx ( edge2 , end ) ; assert ( edge2 != getClusterFirstEdge ( cluster_1 ) ) ; setEdgeCluster_ ( edge2 , end , cluster_1 ) ; edge2 = nextEdge2 ; } while ( edge2 != lastEdge ) ; firstEdge1 = getClusterFirstEdge ( cluster_1 ) ; if ( firstEdge1 != - 1 ) { int next1 = getNextEdge ( firstEdge1 , cluster_1 ) ; int next2 = getNextEdge ( firstEdge2 , cluster_1 ) ; if ( next1 == firstEdge1 ) { setClusterFirstEdge_ ( cluster_1 , firstEdge2 ) ; addEdgeToClusterImpl_ ( firstEdge1 , cluster_1 ) ; setClusterFirstEdge_ ( cluster_1 , firstEdge1 ) ; } else if ( next2 == firstEdge2 ) { addEdgeToClusterImpl_ ( firstEdge2 , cluster_1 ) ; } setNextEdge_ ( firstEdge2 , cluster_1 , next1 ) ; setPrevEdge_ ( next1 , cluster_1 , firstEdge2 ) ; setNextEdge_ ( firstEdge1 , cluster_1 , next2 ) ; setPrevEdge_ ( next2 , cluster_1 , firstEdge1 ) ; } else { setClusterFirstEdge_ ( cluster_1 , firstEdge2 ) ; } } } int vertices1 = getClusterVertices ( cluster_1 ) ; int vertices2 = getClusterVertices ( cluster2 ) ; for ( int vh = m_cluster_vertices . getFirst ( vertices2 ) ; vh != - 1 ; vh = m_cluster_vertices . getNext ( vh ) ) { int v = m_cluster_vertices . getElement ( vh ) ; m_shape . setUserIndex ( v , m_vertex_cluster_index , cluster_1 ) ; } m_cluster_vertices . concatenateLists ( vertices1 , vertices2 ) ; deleteCluster_ ( cluster2 ) ; } | Merges two coincident clusters into one . The cluster2 becomes invalid . |
26,283 | void mergeEdges_ ( int edge1 , int edge2 ) { 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 originVertices2 = getEdgeOriginVertices ( edge2 ) ; m_edge_vertices . concatenateLists ( originVertices1 , originVertices2 ) ; if ( edge2 == getClusterFirstEdge ( cluster_1 ) ) setClusterFirstEdge_ ( cluster_1 , edge1 ) ; if ( edge2 == getClusterFirstEdge ( cluster2 ) ) setClusterFirstEdge_ ( cluster2 , edge1 ) ; disconnectEdge_ ( edge2 ) ; deleteEdge_ ( edge2 ) ; if ( ! ( ( cluster_1 == cluster21 && cluster2 == cluster22 ) || ( cluster2 == cluster21 && cluster_1 == cluster22 ) ) ) { getClusterXY ( cluster_1 , pt_1 ) ; getClusterXY ( cluster21 , pt_2 ) ; if ( pt_1 . isEqual ( pt_2 ) ) { if ( cluster_1 != cluster21 ) { mergeClusters_ ( cluster_1 , cluster21 ) ; assert ( ! m_modified_clusters . hasElement ( cluster21 ) ) ; } if ( cluster2 != cluster22 ) { mergeClusters_ ( cluster2 , cluster22 ) ; assert ( ! m_modified_clusters . hasElement ( cluster22 ) ) ; } } else { if ( cluster2 != cluster21 ) { mergeClusters_ ( cluster2 , cluster21 ) ; assert ( ! m_modified_clusters . hasElement ( cluster21 ) ) ; } if ( cluster_1 != cluster22 ) { mergeClusters_ ( cluster_1 , cluster22 ) ; assert ( ! m_modified_clusters . hasElement ( cluster22 ) ) ; } } } else { } } | Merges two coincident edges into one . The edge2 becomes invalid . |
26,284 | void disconnectEdge_ ( int edge ) { int cluster_1 = getEdgeCluster ( edge , 0 ) ; int cluster2 = getEdgeCluster ( edge , 1 ) ; disconnectEdgeFromCluster_ ( edge , cluster_1 ) ; disconnectEdgeFromCluster_ ( edge , cluster2 ) ; } | Disconnects the edge from its clusters . |
26,285 | 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_ ( prev , cluster , next ) ; setPrevEdge_ ( next , cluster , prev ) ; if ( first_edge == edge ) setClusterFirstEdge_ ( cluster , next ) ; } else setClusterFirstEdge_ ( cluster , - 1 ) ; } | Disconnects the edge from a cluster it is connected to . |
26,286 | void fillEventQueue ( ) { AttributeStreamOfInt32 event_q = new AttributeStreamOfInt32 ( 0 ) ; event_q . reserve ( m_shape . getTotalPointCount ( ) ) ; EditShape . VertexIterator iter = m_shape . queryVertexIterator ( ) ; for ( int vert = iter . next ( ) ; vert != - 1 ; vert = iter . next ( ) ) { if ( m_shape . getUserIndex ( vert , m_vertex_cluster_index ) != - 1 ) event_q . add ( vert ) ; } m_shape . sortVerticesSimpleByY_ ( event_q , 0 , event_q . size ( ) ) ; m_event_q . clear ( ) ; m_event_q . setCapacity ( event_q . size ( ) ) ; { m_event_q . setComparator ( new QComparator ( m_shape ) ) ; } Point2D cluster_pt = new Point2D ( ) ; cluster_pt . setNaN ( ) ; int cluster = - 1 ; Point2D pt = new Point2D ( ) ; for ( int index = 0 , nvertex = event_q . size ( ) ; index < nvertex ; index ++ ) { int vertex = event_q . get ( index ) ; m_shape . getXY ( vertex , pt ) ; if ( pt . isEqual ( cluster_pt ) ) { int vertexCluster = m_shape . getUserIndex ( vertex , m_vertex_cluster_index ) ; mergeClusters_ ( cluster , vertexCluster ) ; continue ; } cluster = getClusterFromVertex ( vertex ) ; m_shape . getXY ( vertex , cluster_pt ) ; int eventQnode = m_event_q . addBiggestElement ( vertex , - 1 ) ; setClusterEventQNode_ ( cluster , eventQnode ) ; } } | Fills the event queue and merges coincident clusters . |
26,287 | 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 ) ; } edge = getNextEdge ( edge , cluster ) ; } while ( edge != first_edge ) ; } | change of cluster coordinate . |
26,288 | 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 ) ; } } | Updates all vertices of the cluster to new coordinate |
26,289 | void getClusterXY ( int cluster , Point2D ptOut ) { int vindex = getClusterVertexIndex ( cluster ) ; m_shape . getXYWithIndex ( vindex , ptOut ) ; } | Returns a cluster s xy . |
26,290 | 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 . m_cell_size ; return clusterer . clusterNonReciprocal_ ( ) ; } | the tolerance in the first - found - first - clustered order ) |
26,291 | 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 ; } | makes sure Simplified shape is more robust to transformations . |
26,292 | 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 ] = rank_1 ; w_res [ 0 ] = w_1 ; } return res ; } else if ( rank_2 > rank_1 ) { pt_res = pt_2 ; if ( w_res != null ) { rank_res [ 0 ] = rank_1 ; w_res [ 0 ] = w_1 ; } return res ; } pt_res = pt_1 ; Point2D pt2d = new Point2D ( ) ; mergeVertices2D ( pt_1 . getXY ( ) , pt_2 . getXY ( ) , w_1 , rank_1 , w_2 , rank_2 , pt2d , w_res , rank_res ) ; pt_res . setXY ( pt2d ) ; return res ; } | return true if the coordinates has changed . |
26,293 | 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 ( ) ; } | these are special implementations all others delegate to the topo - graph . |
26,294 | void dissolveCommonEdges_ ( ) { int visitedEdges = m_topo_graph . createUserIndexForHalfEdges ( ) ; AttributeStreamOfInt32 edgesToDelete = new AttributeStreamOfInt32 ( 0 ) ; for ( int cluster = m_topo_graph . getFirstCluster ( ) ; cluster != - 1 ; cluster = m_topo_graph . getNextCluster ( cluster ) ) { int firstHalfEdge = m_topo_graph . getClusterHalfEdge ( cluster ) ; int half_edge = firstHalfEdge ; if ( firstHalfEdge == - 1 ) continue ; do { int visited = m_topo_graph . getHalfEdgeUserIndex ( half_edge , visitedEdges ) ; if ( visited != 1 ) { int halfEdgeTwin = m_topo_graph . getHalfEdgeTwin ( half_edge ) ; m_topo_graph . setHalfEdgeUserIndex ( halfEdgeTwin , visitedEdges , 1 ) ; m_topo_graph . setHalfEdgeUserIndex ( half_edge , visitedEdges , 1 ) ; int parentage = m_topo_graph . getHalfEdgeFaceParentage ( half_edge ) ; if ( isGoodParentage ( parentage ) ) { int twinParentage = m_topo_graph . getHalfEdgeFaceParentage ( halfEdgeTwin ) ; if ( isGoodParentage ( twinParentage ) ) { edgesToDelete . add ( half_edge ) ; } } } half_edge = m_topo_graph . getHalfEdgeNext ( m_topo_graph . getHalfEdgeTwin ( half_edge ) ) ; } while ( half_edge != firstHalfEdge ) ; } m_topo_graph . deleteUserIndexForHalfEdges ( visitedEdges ) ; m_topo_graph . deleteEdgesBreakFaces_ ( edgesToDelete ) ; } | dissolved faces . Only face parentage will be uasable . |
26,295 | 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 ( ) ) ; } } | Creates a JsonReader for the string . The nextToken is not called by this method . |
26,296 | 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 ) ; accel . _setQuadTree ( null ) ; } } } | Removes accelerators from given geometry . |
26,297 | 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 ; return false ; } Point2D pt_a = point_a . getXY ( ) ; Envelope2D env_b = new Envelope2D ( ) , env_merged = new Envelope2D ( ) ; envelope_b . queryEnvelope2D ( env_b ) ; env_merged . setCoords ( pt_a ) ; env_merged . merge ( env_b ) ; double tolerance = InternalUtils . calculateToleranceFromGeometry ( sr , env_merged , false ) ; switch ( relation ) { case Relation . disjoint : return pointDisjointEnvelope_ ( pt_a , env_b , tolerance , progress_tracker ) ; case Relation . within : return pointWithinEnvelope_ ( pt_a , env_b , tolerance , progress_tracker ) ; case Relation . contains : return pointContainsEnvelope_ ( pt_a , env_b , tolerance , progress_tracker ) ; case Relation . equals : return pointEqualsEnvelope_ ( pt_a , env_b , tolerance , progress_tracker ) ; case Relation . touches : return pointTouchesEnvelope_ ( pt_a , env_b , tolerance , progress_tracker ) ; default : break ; } return false ; } | interior and exterior of point_a vs envelope_b for the given relation . |
26,298 | 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 ; return false ; } Point2D pt_a = point_a . getXY ( ) ; Point2D pt_b = point_b . getXY ( ) ; Envelope2D env_merged = new Envelope2D ( ) ; env_merged . setCoords ( pt_a ) ; env_merged . merge ( pt_b ) ; double tolerance = InternalUtils . calculateToleranceFromGeometry ( sr , env_merged , false ) ; switch ( relation ) { case Relation . disjoint : return pointDisjointPoint_ ( pt_a , pt_b , tolerance , progress_tracker ) ; case Relation . within : return pointContainsPoint_ ( pt_b , pt_a , tolerance , progress_tracker ) ; case Relation . contains : return pointContainsPoint_ ( pt_a , pt_b , tolerance , progress_tracker ) ; case Relation . equals : return pointEqualsPoint_ ( pt_a , pt_b , tolerance , progress_tracker ) ; default : break ; } return false ; } | interior and exterior of point_a vs point_b for the given relation . |
26,299 | 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 ) ; if ( ! envelopeEqualsEnvelope_ ( env_a , env_b , tolerance , progress_tracker ) ) return false ; int relation = tryRasterizedContainsOrDisjoint_ ( polygon_a , polygon_b , tolerance , false ) ; if ( relation == Relation . disjoint || relation == Relation . contains || relation == Relation . within ) return false ; if ( multiPathExactlyEqualsMultiPath_ ( polygon_a , polygon_b , tolerance , progress_tracker ) ) return true ; double length_a = polygon_a . calculateLength2D ( ) ; double length_b = polygon_b . calculateLength2D ( ) ; int max_vertices = Math . max ( polygon_a . getPointCount ( ) , polygon_b . getPointCount ( ) ) ; if ( Math . abs ( length_a - length_b ) > max_vertices * 4.0 * tolerance ) return false ; return linearPathEqualsLinearPath_ ( polygon_a , polygon_b , tolerance , true ) ; } | Returns true if polygon_a equals polygon_b . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.