L_GWireGetMinPath

L_VOID FreeGWireData(L_INT SeedPointsCount, L_POINT* PathsBuf[], GWIREHANDLE* pHGWire) 
{ 
    for (int j = 0 ; j < SeedPointsCount ; j++) 
    { 
        L_FreeGWirePath(PathsBuf[j]); 
    } 
 
    L_DestroyGWireHandle(*pHGWire); 
} 
 
L_INT GWireExample(L_VOID) 
{ 
    L_INT nRet; 
    BITMAPHANDLE LeadBitmap;   /* Bitmap handle to hold the loaded image. */ 
 
    /* Load the bitmap, keeping the bits per pixel of the file */ 
    nRet = L_LoadBitmap (MAKE_IMAGE_PATH(TEXT("IMAGE3.dcm")), &LeadBitmap, sizeof(BITMAPHANDLE), 0, ORDER_BGR, NULL, NULL); 
    if(nRet != SUCCESS) 
        return nRet ; 
 
    GWIREHANDLE HGWire ; 
    L_INT       nExternalEnergy               = 90 ; 
    const L_INT SeedPointsCount               = 9 ; 
    L_POINT*    pOutPath[SeedPointsCount]     = {} ; 
    L_INT       pOutLength[SeedPointsCount]   = {} ; 
    L_POINT     SeedPoints[SeedPointsCount+1] ; 
    L_INT       length                        = 0 ; 
 
    nRet = L_GWireInit(&LeadBitmap, &HGWire, nExternalEnergy); 
    if (nRet != SUCCESS) 
        return nRet ; 
 
    SeedPoints[0].x = 200 ; SeedPoints[0].y = 163 ; 
    SeedPoints[1].x = 245 ; SeedPoints[1].y = 195 ; 
    SeedPoints[2].x = 289 ; SeedPoints[2].y = 163 ; 
    SeedPoints[3].x = 282 ; SeedPoints[3].y = 188 ; 
    SeedPoints[4].x = 304 ; SeedPoints[4].y = 314 ; 
    SeedPoints[5].x = 247 ; SeedPoints[5].y = 271 ; 
    SeedPoints[6].x = 201 ; SeedPoints[6].y = 315 ; 
    SeedPoints[7].x = 228 ; SeedPoints[7].y = 199 ; 
    SeedPoints[8].x = 199 ; SeedPoints[8].y = 175 ; 
    SeedPoints[9].x = 200 ; SeedPoints[9].y = 163 ; 
 
    // Loop over the list of SeedPoints to get the minimum path between each set of two points. 
    // And add the minimum path between the two points to the AllPaths List. 
    for (int index = 0 ; index < SeedPointsCount ; index++ ) 
    { 
        // Set the seed point. 
        nRet = L_GWireSetSeedPoint(HGWire, SeedPoints[index]) ; 
 
        // Get the minimum path from the seed point to the target point. 
        if(nRet == SUCCESS) 
        { 
            nRet = L_GWireGetMinPath(HGWire, SeedPoints[index+1], &(pOutPath[index]), &(pOutLength[index])) ; 
            length += pOutLength[index] ; 
        } 
 
        if(nRet != SUCCESS) 
        { 
            FreeGWireData(SeedPointsCount, pOutPath, &HGWire); 
 
            if(LeadBitmap.Flags.Allocated) 
                L_FreeBitmap(&LeadBitmap); 
 
            return nRet ; 
        } 
    } 
 
    L_POINT* pCombinedPaths = (L_POINT*) malloc((length)*sizeof(L_POINT)); 
    if(pCombinedPaths == NULL) 
    { 
        FreeGWireData(SeedPointsCount, pOutPath, &HGWire); 
 
        if(LeadBitmap.Flags.Allocated) 
            L_FreeBitmap(&LeadBitmap); 
 
        return ERROR_NO_MEMORY; 
    } 
 
    L_INT outIdx = 0 ; 
    for(L_INT index = 0 ; index < 9 ; index++ ) 
    { 
        memcpy(pCombinedPaths+outIdx, pOutPath[index], sizeof(L_POINT)*pOutLength[index]) ; 
        outIdx += pOutLength[index] ; 
    } 
 
    FreeGWireData(SeedPointsCount, pOutPath, &HGWire) ; 
 
    nRet = L_SetBitmapRgnPolygon(&LeadBitmap, NULL, pCombinedPaths, length, L_POLY_WINDING, L_RGN_SET); 
 
    free(pCombinedPaths) ; 
 
    if(nRet == SUCCESS) 
        nRet = L_SaveBitmap(MAKE_IMAGE_PATH(TEXT("Result.BMP")), &LeadBitmap, FILE_BMP, 24, 0, NULL) ; 
 
    //free bitmap 
    if(LeadBitmap.Flags.Allocated) 
        L_FreeBitmap(&LeadBitmap) ; 
 
    return nRet ; 
}