IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 10, 2010, 6:14:20 PM (16 years ago)
Author:
Paul Price
Message:

Only use the thread mechanisms if threading is activated; otherwise, the thread tasks probably aren't defined.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/imageops/psImageConvolve.c

    r27910 r27911  
    871871            psFree(job);
    872872        }
     873        if (!psThreadPoolWait(true)) {
     874            psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
     875            psFree(gaussNorm);
     876            psFree(out);
     877            return NULL;
     878        }
    873879    } else if (!imageSmoothMaskPixels(out, image, mask, maskVal, x, y,
    874880                                      gaussNorm, minGauss, size, 0, num)) {
    875881        psError(PS_ERR_UNKNOWN, false, "Unable to smooth pixels.");
    876         psFree(gaussNorm);
    877         psFree(out);
    878         return NULL;
    879     }
    880 
    881     if (threaded && !psThreadPoolWait(true)) {
    882         psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
    883882        psFree(gaussNorm);
    884883        psFree(out);
    … …  
    11921191          psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */
    11931192
    1194           /** Smooth in X direction **/
    1195           for (int rowStart = 0; rowStart < numRows; rowStart+=scanRows) {
    1196               int rowStop = PS_MIN (rowStart + scanRows, numRows);
    1197 
    1198               // allocate a job, construct the arguments for this job
    1199               psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANROWS");
    1200               psArrayAdd(job->args, 1, calculation);
    1201               psArrayAdd(job->args, 1, calcMask);
    1202               psArrayAdd(job->args, 1, (psImage *) image); // cast away const
    1203               psArrayAdd(job->args, 1, (psImage *) mask); // cast away const
    1204               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
    1205               psArrayAdd(job->args, 1, gaussNorm);
    1206               PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    1207               PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
    1208               PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
    1209               PS_ARRAY_ADD_SCALAR(job->args, rowStop,  PS_TYPE_S32);
    1210               // -> psImageSmoothMask_ScanRows_F32 (calculation, calcMask, image, mask, maskVal, gauss, minGauss, size, rowStart, rowStop);
    1211 
    1212               // if threading is not active, we simply run the job and return
    1213               if (!psThreadJobAddPending(job)) {
     1193          if (threaded) {
     1194              /** Smooth in X direction **/
     1195              for (int rowStart = 0; rowStart < numRows; rowStart+=scanRows) {
     1196                  int rowStop = PS_MIN (rowStart + scanRows, numRows);
     1197
     1198                  // allocate a job, construct the arguments for this job
     1199                  psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANROWS");
     1200                  psArrayAdd(job->args, 1, calculation);
     1201                  psArrayAdd(job->args, 1, calcMask);
     1202                  psArrayAdd(job->args, 1, (psImage *) image); // cast away const
     1203                  psArrayAdd(job->args, 1, (psImage *) mask); // cast away const
     1204                  PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
     1205                  psArrayAdd(job->args, 1, gaussNorm);
     1206                  PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
     1207                  PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
     1208                  PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     1209                  PS_ARRAY_ADD_SCALAR(job->args, rowStop,  PS_TYPE_S32);
     1210                  // -> psImageSmoothMask_ScanRows_F32 (calculation, calcMask, image, mask, maskVal, gauss, minGauss, size, rowStart, rowStop);
     1211
     1212                  // if threading is not active, we simply run the job and return
     1213                  if (!psThreadJobAddPending(job)) {
     1214                      psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1215                      psFree(job);
     1216                      psFree(calculation);
     1217                      psFree(calcMask);
     1218                      psFree(gaussNorm);
     1219                      return false;
     1220                  }
     1221                  psFree(job);
     1222              }
     1223              // wait here for the threaded jobs to finish (NOP if threading is not active)
     1224              if (!psThreadPoolWait(true)) {
    12141225                  psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1215                   psFree(job);
     1226                  psFree(calculation);
     1227                  psFree(calcMask);
     1228                  psFree(gaussNorm);
    12161229                  return false;
    12171230              }
    1218               psFree(job);
    1219 
    1220           }
    1221 
    1222           // wait here for the threaded jobs to finish (NOP if threading is not active)
    1223           if (!psThreadPoolWait(true)) {
     1231          } else if (!psImageSmoothMask_ScanRows_F32(calculation, calcMask, image, mask, maskVal,
     1232                                                     gaussNorm, minGauss, size, 0, numRows)) {
    12241233              psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1234              psFree(calculation);
     1235              psFree(calcMask);
     1236              psFree(gaussNorm);
    12251237              return false;
    12261238          }
    … …  
    12291241
    12301242          /** Smooth in Y direction  **/
    1231           for (int colStart = 0; colStart < numCols; colStart+=scanCols) {
    1232               int colStop = PS_MIN (colStart + scanCols, numCols);
    1233 
    1234               // allocate a job, construct the arguments for this job
    1235               psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANCOLS");
    1236               psArrayAdd(job->args, 1, output);
    1237               psArrayAdd(job->args, 1, calculation);
    1238               psArrayAdd(job->args, 1, calcMask);
    1239               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
    1240               psArrayAdd(job->args, 1, gaussNorm);
    1241               PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    1242               PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
    1243               PS_ARRAY_ADD_SCALAR(job->args, colStart, PS_TYPE_S32);
    1244               PS_ARRAY_ADD_SCALAR(job->args, colStop,  PS_TYPE_S32);
    1245               // -> psImageSmoothMask_ScanCols_F32 (output, calculation, calcMask, maskVal, gauss, minGauss, size, colStart, colStop);
    1246 
    1247               // if threading is not active, we simply run the job and return
    1248               if (!psThreadJobAddPending(job)) {
     1243          if (threaded) {
     1244              for (int colStart = 0; colStart < numCols; colStart+=scanCols) {
     1245                  int colStop = PS_MIN (colStart + scanCols, numCols);
     1246
     1247                  // allocate a job, construct the arguments for this job
     1248                  psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANCOLS");
     1249                  psArrayAdd(job->args, 1, output);
     1250                  psArrayAdd(job->args, 1, calculation);
     1251                  psArrayAdd(job->args, 1, calcMask);
     1252                  PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_IMAGE_MASK);
     1253                  psArrayAdd(job->args, 1, gaussNorm);
     1254                  PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
     1255                  PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
     1256                  PS_ARRAY_ADD_SCALAR(job->args, colStart, PS_TYPE_S32);
     1257                  PS_ARRAY_ADD_SCALAR(job->args, colStop,  PS_TYPE_S32);
     1258                  // -> psImageSmoothMask_ScanCols_F32 (output, calculation, calcMask, maskVal, gauss, minGauss, size, colStart, colStop);
     1259
     1260                  // if threading is not active, we simply run the job and return
     1261                  if (!psThreadJobAddPending(job)) {
     1262                      psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1263                      psFree(job);
     1264                      psFree(calculation);
     1265                      psFree(calcMask);
     1266                      psFree(gaussNorm);
     1267                      return false;
     1268                  }
     1269                  psFree(job);
     1270              }
     1271
     1272              // wait here for the threaded jobs to finish (NOP if threading is not active)
     1273              if (!psThreadPoolWait(true)) {
    12491274                  psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1250                   psFree(job);
     1275                  psFree(calculation);
     1276                  psFree(calcMask);
     1277                  psFree(gaussNorm);
    12511278                  return false;
    12521279              }
    1253               psFree(job);
    1254           }
    1255 
    1256           // wait here for the threaded jobs to finish (NOP if threading is not active)
    1257           if (!psThreadPoolWait(true)) {
     1280          } else if (!psImageSmoothMask_ScanCols_F32(output, calculation, calcMask, maskVal,
     1281                                                     gaussNorm, minGauss, size, 0, numCols)) {
    12581282              psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1283              psFree(calculation);
     1284              psFree(calcMask);
     1285              psFree(gaussNorm);
    12591286              return false;
    12601287          }
     1288
    12611289          psFree(calculation);
    12621290          psFree(calcMask);
    … …  
    15591587            psFree(job);
    15601588        }
     1589        if (!psThreadPoolWait(true)) {
     1590            psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
     1591            psFree(conv);
     1592            psFree(out);
     1593            return NULL;
     1594        }
    15611595    } else if (!imageConvolveMaskColumns(conv, mask, 0, numRows, maskVal, xMin, xMax)) {
    15621596        psError(PS_ERR_UNKNOWN, false, "Unable to convolve mask columns.");
    1563         psFree(conv);
    1564         psFree(out);
    1565         return NULL;
    1566     }
    1567 
    1568     if (threaded && !psThreadPoolWait(true)) {
    1569         psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
    15701597        psFree(conv);
    15711598        psFree(out);
    … …  
    15971624            psFree(job);
    15981625        }
     1626        if (!psThreadPoolWait(true)) {
     1627            psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
     1628            psFree(conv);
     1629            psFree(out);
     1630            return NULL;
     1631        }
    15991632    } else if (!imageConvolveMaskRows(out, conv, 0, numCols, setVal, yMin, yMax)) {
    16001633        psError(PS_ERR_UNKNOWN, false, "Unable to convolve mask columns.");
    1601         psFree(conv);
    1602         psFree(out);
    1603         return NULL;
    1604     }
    1605 
    1606     if (threaded && !psThreadPoolWait(true)) {
    1607         psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
    16081634        psFree(conv);
    16091635        psFree(out);
Note: See TracChangeset for help on using the changeset viewer.