SHPRewindObject()

int SHPAPI_CALL SHPRewindObject	(	CPL_UNUSED SHPHandle	hSHP,
		SHPObject *	psObject
	)

Definition at line 2778 of file shpopen.c.

{
    int  iOpRing, bAltered = 0;
 
/* -------------------------------------------------------------------- */
/*      Do nothing if this is not a polygon object.                     */
/* -------------------------------------------------------------------- */
    if( psObject->nSHPType != SHPT_POLYGON
        && psObject->nSHPType != SHPT_POLYGONZ
        && psObject->nSHPType != SHPT_POLYGONM )
        return 0;
 
    if( psObject->nVertices == 0 || psObject->nParts == 0 )
        return 0;
 
/* -------------------------------------------------------------------- */
/*      Process each of the rings.                                      */
/* -------------------------------------------------------------------- */
    for( iOpRing = 0; iOpRing < psObject->nParts; iOpRing++ )
    {
        int      bInner = FALSE;
        int      iVert;
        double   dfSum;
 
        const int nVertStart = psObject->panPartStart[iOpRing];
        const int nVertCount = SHPGetPartVertexCount(psObject, iOpRing);
 
        if (nVertCount < 2)
            continue;
 
        for( iVert = nVertStart; iVert + 1 < nVertStart + nVertCount; ++iVert )
        {
            /* Use point in the middle of segment to avoid testing
            * common points of rings.
            */
            const double dfTestX = ( psObject->padfX[iVert] +
                                     psObject->padfX[iVert + 1] ) / 2;
            const double dfTestY = ( psObject->padfY[iVert] +
                                     psObject->padfY[iVert + 1] ) / 2;
 
            bInner = SHPRewindIsInnerRing(psObject, iOpRing, dfTestX, dfTestY);
            if( bInner >= 0 )
                break;
        }
        if( bInner < 0 )
        {
            /* Completely degenerate case. Do not bother touching order. */
            continue;
        }
 
/* -------------------------------------------------------------------- */
/*      Determine the current order of this ring so we will know if     */
/*      it has to be reversed.                                          */
/* -------------------------------------------------------------------- */
 
        dfSum = psObject->padfX[nVertStart] *
                        (psObject->padfY[nVertStart+1] -
                         psObject->padfY[nVertStart+nVertCount-1]);
        for( iVert = nVertStart + 1; iVert < nVertStart+nVertCount-1; iVert++ )
        {
            dfSum += psObject->padfX[iVert] * (psObject->padfY[iVert+1] -
                                               psObject->padfY[iVert-1]);
        }
 
        dfSum += psObject->padfX[iVert] * (psObject->padfY[nVertStart] -
                                           psObject->padfY[iVert-1]);
 
/* -------------------------------------------------------------------- */
/*      Reverse if necessary.                                           */
/* -------------------------------------------------------------------- */
        if( (dfSum < 0.0 && bInner) || (dfSum > 0.0 && !bInner) )
        {
            int   i;
 
            bAltered++;
            for( i = 0; i < nVertCount/2; i++ )
            {
                double dfSaved;
 
                /* Swap X */
                dfSaved = psObject->padfX[nVertStart+i];
                psObject->padfX[nVertStart+i] =
                    psObject->padfX[nVertStart+nVertCount-i-1];
                psObject->padfX[nVertStart+nVertCount-i-1] = dfSaved;
 
                /* Swap Y */
                dfSaved = psObject->padfY[nVertStart+i];
                psObject->padfY[nVertStart+i] =
                    psObject->padfY[nVertStart+nVertCount-i-1];
                psObject->padfY[nVertStart+nVertCount-i-1] = dfSaved;
 
                /* Swap Z */
                if( psObject->padfZ )
                {
                    dfSaved = psObject->padfZ[nVertStart+i];
                    psObject->padfZ[nVertStart+i] =
                        psObject->padfZ[nVertStart+nVertCount-i-1];
                    psObject->padfZ[nVertStart+nVertCount-i-1] = dfSaved;
                }
 
                /* Swap M */
                if( psObject->padfM )
                {
                    dfSaved = psObject->padfM[nVertStart+i];
                    psObject->padfM[nVertStart+i] =
                        psObject->padfM[nVertStart+nVertCount-i-1];
                    psObject->padfM[nVertStart+nVertCount-i-1] = dfSaved;
                }
            }
        }
    }
 
    return bAltered;
}

References FALSE, tagSHPObject::nParts, tagSHPObject::nSHPType, tagSHPObject::nVertices, tagSHPObject::padfM, tagSHPObject::padfX, tagSHPObject::padfY, tagSHPObject::padfZ, tagSHPObject::panPartStart, SHPGetPartVertexCount(), SHPRewindIsInnerRing(), SHPT_POLYGON, SHPT_POLYGONM, and SHPT_POLYGONZ.

Here is the call graph for this function: