SHPRewindIsInnerRing()

static int SHPRewindIsInnerRing ( const SHPObject *  psObject, int  iOpRing, double  dfTestX, double  dfTestY  )

static

Definition at line 2689 of file shpopen.c.

{
/* -------------------------------------------------------------------- */
/*      Determine if this ring is an inner ring or an outer ring        */
/*      relative to all the other rings.  For now we assume the         */
/*      first ring is outer and all others are inner, but eventually    */
/*      we need to fix this to handle multiple island polygons and      */
/*      unordered sets of rings.                                        */
/*                                                                      */
/* -------------------------------------------------------------------- */
 
    int bInner = FALSE;
    int iCheckRing;
    for( iCheckRing = 0; iCheckRing < psObject->nParts; iCheckRing++ )
    {
        int nVertStartCheck, nVertCountCheck;
        int iEdge;
 
        if( iCheckRing == iOpRing )
            continue;
 
        nVertStartCheck = psObject->panPartStart[iCheckRing];
        nVertCountCheck = SHPGetPartVertexCount(psObject, iCheckRing);
 
        for( iEdge = 0; iEdge < nVertCountCheck; iEdge++ )
        {
            int iNext;
 
            if( iEdge < nVertCountCheck-1 )
                iNext = iEdge+1;
            else
                iNext = 0;
 
            /* Rule #1:
             * Test whether the edge 'straddles' the horizontal ray from
             * the test point (dfTestY,dfTestY)
             * The rule #1 also excludes edges colinear with the ray.
             */
            if ( ( psObject->padfY[iEdge+nVertStartCheck] < dfTestY
                    && dfTestY <= psObject->padfY[iNext+nVertStartCheck] )
                    || ( psObject->padfY[iNext+nVertStartCheck] < dfTestY
                        && dfTestY <= psObject->padfY[iEdge+nVertStartCheck] ) )
            {
                /* Rule #2:
                 * Test if edge-ray intersection is on the right from the
                 * test point (dfTestY,dfTestY)
                 */
                double const intersect =
                    ( psObject->padfX[iEdge+nVertStartCheck]
                        + ( dfTestY - psObject->padfY[iEdge+nVertStartCheck] )
                        / ( psObject->padfY[iNext+nVertStartCheck] -
                            psObject->padfY[iEdge+nVertStartCheck] )
                        * ( psObject->padfX[iNext+nVertStartCheck] -
                            psObject->padfX[iEdge+nVertStartCheck] ) );
 
                if (intersect < dfTestX)
                {
                    bInner = !bInner;
                }
                else if( intersect == dfTestX )
                {
                    /* Potential shared edge */
                    return -1;
                }
            }
        }
    } /* for iCheckRing */
    return bInner;
}

References FALSE, tagSHPObject::nParts, tagSHPObject::padfX, tagSHPObject::padfY, tagSHPObject::panPartStart, and SHPGetPartVertexCount().

Referenced by SHPRewindObject().

Here is the call graph for this function:

Here is the caller graph for this function: