IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 20830


Ignore:
Timestamp:
Nov 25, 2008, 2:43:12 PM (17 years ago)
Author:
Paul Price
Message:

Return old threading status so it can be restored.

Location:
trunk/psLib/src/imageops
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r20462 r20830  
    77/// @author Eugene Magnier, IfA
    88///
    9 /// @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
    10 /// @date $Date: 2008-10-29 20:43:18 $
     9/// @version $Revision: 1.81 $ $Name: not supported by cvs2svn $
     10/// @date $Date: 2008-11-26 00:43:12 $
    1111///
    1212/// Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    … …  
    750750    switch (image->type.type) {
    751751      case PS_TYPE_F32: {
    752           psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
    753           psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
    754    
    755           /** Smooth in X direction **/
    756           for (int j = 0; j < numRows; j++) {
    757               for (int i = 0; i < numCols; i++) {
    758                   int xMin = PS_MAX(i - size, 0);
    759                   int xMax = PS_MIN(i + size, xLast);
    760                   const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
    761                   const psF32 *imageData = &image->data.F32[j][xMin];
    762                   int uMin = - PS_MIN(i, size); /* Minimum kernel index */
    763                   const psF32 *gaussData = &gauss[uMin];
    764                   double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
    765                   for (int x = xMin; x <= xMax; x++, maskData++, imageData++, gaussData++) {
    766                       if (*maskData & maskVal) {
    767                           continue;
    768                       }
    769                       // if ((i == 1000) && (j > 10) && (j < 15)) {
    770                       //          fprintf (stderr, "%d %d  %d  %f  %f   %f %f\n", i, j, x, *imageData, *gaussData, sumIG, sumG);
    771                       // }
    772                       sumIG += *imageData * *gaussData;
    773                       sumG += *gaussData;
    774                   }
    775                   if (sumG > minGauss) {
    776                       /* BW */
    777                       calculation->data.F32[i][j] = sumIG / sumG;
    778                       calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
    779                   } else {
    780                       /* BW */
    781                       calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
    782                   }
    783               }
    784           }
    785    
    786           output = psImageRecycle(output, numCols, numRows, PS_TYPE_F32);
    787    
    788           /** Smooth in Y direction  **/
    789           for (int i = 0; i < numCols; i++) {
    790               for (int j = 0; j < numRows; j++) {
    791                   int yMin = PS_MAX(j - size, 0);
    792                   int yMax = PS_MIN(j + size, yLast);
    793                   const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
    794                   const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
    795                   int vMin = - PS_MIN(j, size); /* Minimum kernel index */
    796                   const psF32 *gaussData = &gauss[vMin];
    797                   double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
    798                   for (int y = yMin; y <= yMax; y++, maskData++, imageData++, gaussData++) {
    799                       if (*maskData) {
    800                           continue;
    801                       }
    802                       sumIG += *imageData * *gaussData;
    803                       sumG += *gaussData;
    804                   }
    805                   output->data.F32[j][i] = (sumG > minGauss) ? sumIG / sumG : NAN;
    806               }
    807           }
    808    
    809           psFree(calculation);
    810           psFree(calcMask);
    811           psFree(gaussNorm);
    812    
    813           return output;
     752          psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
     753          psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
     754
     755          /** Smooth in X direction **/
     756          for (int j = 0; j < numRows; j++) {
     757              for (int i = 0; i < numCols; i++) {
     758                  int xMin = PS_MAX(i - size, 0);
     759                  int xMax = PS_MIN(i + size, xLast);
     760                  const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
     761                  const psF32 *imageData = &image->data.F32[j][xMin];
     762                  int uMin = - PS_MIN(i, size); /* Minimum kernel index */
     763                  const psF32 *gaussData = &gauss[uMin];
     764                  double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
     765                  for (int x = xMin; x <= xMax; x++, maskData++, imageData++, gaussData++) {
     766                      if (*maskData & maskVal) {
     767                          continue;
     768                      }
     769                      // if ((i == 1000) && (j > 10) && (j < 15)) {
     770                      //          fprintf (stderr, "%d %d  %d  %f  %f   %f %f\n", i, j, x, *imageData, *gaussData, sumIG, sumG);
     771                      // }
     772                      sumIG += *imageData * *gaussData;
     773                      sumG += *gaussData;
     774                  }
     775                  if (sumG > minGauss) {
     776                      /* BW */
     777                      calculation->data.F32[i][j] = sumIG / sumG;
     778                      calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
     779                  } else {
     780                      /* BW */
     781                      calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
     782                  }
     783              }
     784          }
     785
     786          output = psImageRecycle(output, numCols, numRows, PS_TYPE_F32);
     787
     788          /** Smooth in Y direction  **/
     789          for (int i = 0; i < numCols; i++) {
     790              for (int j = 0; j < numRows; j++) {
     791                  int yMin = PS_MAX(j - size, 0);
     792                  int yMax = PS_MIN(j + size, yLast);
     793                  const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
     794                  const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
     795                  int vMin = - PS_MIN(j, size); /* Minimum kernel index */
     796                  const psF32 *gaussData = &gauss[vMin];
     797                  double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
     798                  for (int y = yMin; y <= yMax; y++, maskData++, imageData++, gaussData++) {
     799                      if (*maskData) {
     800                          continue;
     801                      }
     802                      sumIG += *imageData * *gaussData;
     803                      sumG += *gaussData;
     804                  }
     805                  output->data.F32[j][i] = (sumG > minGauss) ? sumIG / sumG : NAN;
     806              }
     807          }
     808
     809          psFree(calculation);
     810          psFree(calcMask);
     811          psFree(gaussNorm);
     812
     813          return output;
    814814      }
    815         IMAGESMOOTH_MASK_CASE(F64);
     815        IMAGESMOOTH_MASK_CASE(F64);
    816816      default:
    817         psFree(gaussNorm);
    818         char *typeStr;
    819         PS_TYPE_NAME(typeStr,image->type.type);
    820         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    821                 _("Specified psImage type, %s, is not supported."),
    822                 typeStr);
    823         return false;
     817        psFree(gaussNorm);
     818        char *typeStr;
     819        PS_TYPE_NAME(typeStr,image->type.type);
     820        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     821                _("Specified psImage type, %s, is not supported."),
     822                typeStr);
     823        return false;
    824824    }
    825825
    … …  
    828828}
    829829
    830 bool psImageSmoothMask_ScanRows_F32 (psImage *calculation, 
    831                                      psImage *calcMask,
    832                                      const psImage *image,
    833                                      const psImage *mask,
    834                                      psMaskType maskVal,
    835                                      psVector *gaussNorm,
    836                                      float minGauss,
    837                                      int size,
    838                                      int rowStart,
    839                                      int rowStop)
     830bool psImageSmoothMask_ScanRows_F32 (psImage *calculation,
     831                                     psImage *calcMask,
     832                                     const psImage *image,
     833                                     const psImage *mask,
     834                                     psMaskType maskVal,
     835                                     psVector *gaussNorm,
     836                                     float minGauss,
     837                                     int size,
     838                                     int rowStart,
     839                                     int rowStop)
    840840{
    841841    const psF32 *gauss = &gaussNorm->data.F32[size]; // Gaussian convolution kernel
    … …  
    845845
    846846    for (int j = rowStart; j < rowStop; j++) {
    847         for (int i = 0; i < numCols; i++) {
    848             int xMin = PS_MAX(i - size, 0);
    849             int xMax = PS_MIN(i + size, xLast);
    850             const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
    851             const psF32 *imageData = &image->data.F32[j][xMin];
    852             int uMin = - PS_MIN(i, size); /* Minimum kernel index */
    853             const psF32 *gaussData = &gauss[uMin];
    854             double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
    855             for (int x = xMin; x <= xMax; x++, maskData++, imageData++, gaussData++) {
    856                 if (*maskData & maskVal) {
    857                     continue;
    858                 }
    859                 sumIG += *imageData * *gaussData;
    860                 sumG += *gaussData;
    861             }
    862             if (sumG > minGauss) {
    863                 /* BW */
    864                 calculation->data.F32[i][j] = sumIG / sumG;
    865                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
    866             } else {
    867                 /* BW */
    868                 calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
    869             }
    870         }
     847        for (int i = 0; i < numCols; i++) {
     848            int xMin = PS_MAX(i - size, 0);
     849            int xMax = PS_MIN(i + size, xLast);
     850            const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin];
     851            const psF32 *imageData = &image->data.F32[j][xMin];
     852            int uMin = - PS_MIN(i, size); /* Minimum kernel index */
     853            const psF32 *gaussData = &gauss[uMin];
     854            double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
     855            for (int x = xMin; x <= xMax; x++, maskData++, imageData++, gaussData++) {
     856                if (*maskData & maskVal) {
     857                    continue;
     858                }
     859                sumIG += *imageData * *gaussData;
     860                sumG += *gaussData;
     861            }
     862            if (sumG > minGauss) {
     863                /* BW */
     864                calculation->data.F32[i][j] = sumIG / sumG;
     865                calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0;
     866            } else {
     867                /* BW */
     868                calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF;
     869            }
     870        }
    871871    }
    872872    return true;
    … …  
    874874
    875875bool psImageSmoothMask_ScanCols_F32 (psImage *output,
    876                                      psImage *calculation,
    877                                      psImage *calcMask,
    878                                      psMaskType maskVal,
    879                                      psVector *gaussNorm,
    880                                      float minGauss,
    881                                      int size,
    882                                      int colStart,
    883                                      int colStop)
     876                                     psImage *calculation,
     877                                     psImage *calcMask,
     878                                     psMaskType maskVal,
     879                                     psVector *gaussNorm,
     880                                     float minGauss,
     881                                     int size,
     882                                     int colStart,
     883                                     int colStop)
    884884{
    885885    const psF32 *gauss = &gaussNorm->data.F32[size]; // Gaussian convolution kernel
    … …  
    889889
    890890    for (int i = colStart; i < colStop; i++) {
    891         for (int j = 0; j < numRows; j++) {
    892             int yMin = PS_MAX(j - size, 0);
    893             int yMax = PS_MIN(j + size, yLast);
    894             const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
    895             const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
    896             int vMin = - PS_MIN(j, size); /* Minimum kernel index */
    897             const psF32 *gaussData = &gauss[vMin];
    898             double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
    899             for (int y = yMin; y <= yMax; y++, maskData++, imageData++, gaussData++) {
    900                 if (*maskData) {
    901                     continue;
    902                 }
    903                 sumIG += *imageData * *gaussData;
    904                 sumG += *gaussData;
    905             }
    906             output->data.F32[j][i] = (sumG > minGauss) ? sumIG / sumG : NAN;
    907         }
     891        for (int j = 0; j < numRows; j++) {
     892            int yMin = PS_MAX(j - size, 0);
     893            int yMax = PS_MIN(j + size, yLast);
     894            const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */
     895            const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */
     896            int vMin = - PS_MIN(j, size); /* Minimum kernel index */
     897            const psF32 *gaussData = &gauss[vMin];
     898            double sumIG = 0.0, sumG = 0.0; /* Sums for convolution */
     899            for (int y = yMin; y <= yMax; y++, maskData++, imageData++, gaussData++) {
     900                if (*maskData) {
     901                    continue;
     902                }
     903                sumIG += *imageData * *gaussData;
     904                sumG += *gaussData;
     905            }
     906            output->data.F32[j][i] = (sumG > minGauss) ? sumIG / sumG : NAN;
     907        }
    908908    }
    909909    return true;
    910910}
    911    
     911
    912912bool psImageSmoothMask_ScanRows_F32_Threaded(psThreadJob *job)
    913913{
    … …  
    921921    const psImage *mask   = job->args->data[3]; // input mask
    922922
    923     psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[4],U8);
    924     psVector *gaussNorm   = job->args->data[5]; // gauss kernel
    925     float minGauss        = PS_SCALAR_VALUE(job->args->data[6],F32);
    926     int size              = PS_SCALAR_VALUE(job->args->data[7],S32);
    927     int rowStart          = PS_SCALAR_VALUE(job->args->data[8],S32);
    928     int rowStop           = PS_SCALAR_VALUE(job->args->data[9],S32);
    929     return psImageSmoothMask_ScanRows_F32(calculation, calcMask, image, mask, maskVal, 
    930                                           gaussNorm, minGauss, size,
    931                                           rowStart, rowStop);
     923    psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[4],U8);
     924    psVector *gaussNorm   = job->args->data[5]; // gauss kernel
     925    float minGauss        = PS_SCALAR_VALUE(job->args->data[6],F32);
     926    int size              = PS_SCALAR_VALUE(job->args->data[7],S32);
     927    int rowStart          = PS_SCALAR_VALUE(job->args->data[8],S32);
     928    int rowStop           = PS_SCALAR_VALUE(job->args->data[9],S32);
     929    return psImageSmoothMask_ScanRows_F32(calculation, calcMask, image, mask, maskVal,
     930                                          gaussNorm, minGauss, size,
     931                                          rowStart, rowStop);
    932932}
    933933
    … …  
    941941    psImage *calculation  = job->args->data[1]; // calculation image
    942942    psImage *calcMask     = job->args->data[2]; // calculation mask
    943     psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[3],U8);
    944 
    945     psVector *gaussNorm   = job->args->data[4]; // gauss kernel
    946     float minGauss        = PS_SCALAR_VALUE(job->args->data[5],F32);
    947     int size              = PS_SCALAR_VALUE(job->args->data[6],S32);
    948     int colStart          = PS_SCALAR_VALUE(job->args->data[7],S32);
    949     int colStop           = PS_SCALAR_VALUE(job->args->data[8],S32);
    950     return psImageSmoothMask_ScanCols_F32(output, calculation, calcMask, maskVal, 
    951                                           gaussNorm, minGauss, size,
    952                                           colStart, colStop);
     943    psMaskType maskVal    = PS_SCALAR_VALUE(job->args->data[3],U8);
     944
     945    psVector *gaussNorm   = job->args->data[4]; // gauss kernel
     946    float minGauss        = PS_SCALAR_VALUE(job->args->data[5],F32);
     947    int size              = PS_SCALAR_VALUE(job->args->data[6],S32);
     948    int colStart          = PS_SCALAR_VALUE(job->args->data[7],S32);
     949    int colStop           = PS_SCALAR_VALUE(job->args->data[8],S32);
     950    return psImageSmoothMask_ScanCols_F32(output, calculation, calcMask, maskVal,
     951                                          gaussNorm, minGauss, size,
     952                                          colStart, colStop);
    953953}
    954954
    955955psImage *psImageSmoothMask_Threaded(psImage *output,
    956                                     const psImage *image,
    957                                     const psImage *mask,
    958                                     psMaskType maskVal,
    959                                     float sigma,
    960                                     float numSigma,
    961                                     float minGauss)
     956                                    const psImage *image,
     957                                    const psImage *mask,
     958                                    psMaskType maskVal,
     959                                    float sigma,
     960                                    float numSigma,
     961                                    float minGauss)
    962962{
    963963    PS_ASSERT_IMAGE_NON_NULL(image, NULL);
    … …  
    993993
    994994    switch (image->type.type) {
    995         // Smooth an image with masked pixels
    996         // The calculation and calcMask images are *deliberately* backwards (row,col instead of col,row or
    997         // [col][row] instead of [row][col]) to optimise the iteration over rows; such instances are marked "BW"
     995        // Smooth an image with masked pixels
     996        // The calculation and calcMask images are *deliberately* backwards (row,col instead of col,row or
     997        // [col][row] instead of [row][col]) to optimise the iteration over rows; such instances are marked "BW"
    998998
    999999      case PS_TYPE_F32: {
    1000           psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
    1001           psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
    1002    
    1003           /** Smooth in X direction **/
    1004           for (int rowStart = 0; rowStart < numRows; rowStart+=scanRows) {
    1005               int rowStop = PS_MIN (rowStart + scanRows, numRows);
    1006 
    1007               // allocate a job, construct the arguments for this job
    1008               psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANROWS");
    1009               psArrayAdd(job->args, 1, calculation);
    1010               psArrayAdd(job->args, 1, calcMask);
    1011               psArrayAdd(job->args, 1, (psImage *) image); // cast away const
    1012               psArrayAdd(job->args, 1, (psImage *) mask); // cast away const
    1013               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
    1014               psArrayAdd(job->args, 1, gaussNorm);
    1015               PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    1016               PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
    1017               PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
    1018               PS_ARRAY_ADD_SCALAR(job->args, rowStop,  PS_TYPE_S32);
    1019               // -> psImageSmoothMask_ScanRows_F32 (calculation, calcMask, image, mask, maskVal, gauss, minGauss, size, rowStart, rowStop);
    1020 
    1021               // if threading is not active, we simply run the job and return
    1022               if (!psThreadJobAddPending(job)) {
    1023                   psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1024                   psFree(job);
    1025                   return false;
    1026               }
    1027               psFree(job);
    1028 
    1029           }
    1030 
    1031           // wait here for the threaded jobs to finish (NOP if threading is not active)
    1032           if (!psThreadPoolWait(true)) {
    1033               psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1034               return false;
    1035           }
    1036 
    1037           output = psImageRecycle(output, numCols, numRows, PS_TYPE_F32);
    1038    
    1039           /** Smooth in Y direction  **/
    1040           for (int colStart = 0; colStart < numCols; colStart+=scanCols) {
    1041               int colStop = PS_MIN (colStart + scanCols, numCols);
    1042 
    1043               // allocate a job, construct the arguments for this job
    1044               psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANCOLS");
    1045               psArrayAdd(job->args, 1, output);
    1046               psArrayAdd(job->args, 1, calculation);
    1047               psArrayAdd(job->args, 1, calcMask);
    1048               PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
    1049               psArrayAdd(job->args, 1, gaussNorm);
    1050               PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
    1051               PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
    1052               PS_ARRAY_ADD_SCALAR(job->args, colStart, PS_TYPE_S32);
    1053               PS_ARRAY_ADD_SCALAR(job->args, colStop,  PS_TYPE_S32);
    1054               // -> psImageSmoothMask_ScanCols_F32 (output, calculation, calcMask, maskVal, gauss, minGauss, size, colStart, colStop);
    1055 
    1056               // if threading is not active, we simply run the job and return
    1057               if (!psThreadJobAddPending(job)) {
    1058                   psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1059                   psFree(job);
    1060                   return false;
    1061               }
    1062               psFree(job);
    1063           }
    1064 
    1065           // wait here for the threaded jobs to finish (NOP if threading is not active)
    1066           if (!psThreadPoolWait(true)) {
    1067               psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
    1068               return false;
    1069           }
    1070           psFree(calculation);
    1071           psFree(calcMask);
    1072           psFree(gaussNorm);
    1073    
    1074           return output;
     1000          psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */
     1001          psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */
     1002
     1003          /** Smooth in X direction **/
     1004          for (int rowStart = 0; rowStart < numRows; rowStart+=scanRows) {
     1005              int rowStop = PS_MIN (rowStart + scanRows, numRows);
     1006
     1007              // allocate a job, construct the arguments for this job
     1008              psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANROWS");
     1009              psArrayAdd(job->args, 1, calculation);
     1010              psArrayAdd(job->args, 1, calcMask);
     1011              psArrayAdd(job->args, 1, (psImage *) image); // cast away const
     1012              psArrayAdd(job->args, 1, (psImage *) mask); // cast away const
     1013              PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
     1014              psArrayAdd(job->args, 1, gaussNorm);
     1015              PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
     1016              PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
     1017              PS_ARRAY_ADD_SCALAR(job->args, rowStart, PS_TYPE_S32);
     1018              PS_ARRAY_ADD_SCALAR(job->args, rowStop,  PS_TYPE_S32);
     1019              // -> psImageSmoothMask_ScanRows_F32 (calculation, calcMask, image, mask, maskVal, gauss, minGauss, size, rowStart, rowStop);
     1020
     1021              // if threading is not active, we simply run the job and return
     1022              if (!psThreadJobAddPending(job)) {
     1023                  psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1024                  psFree(job);
     1025                  return false;
     1026              }
     1027              psFree(job);
     1028
     1029          }
     1030
     1031          // wait here for the threaded jobs to finish (NOP if threading is not active)
     1032          if (!psThreadPoolWait(true)) {
     1033              psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1034              return false;
     1035          }
     1036
     1037          output = psImageRecycle(output, numCols, numRows, PS_TYPE_F32);
     1038
     1039          /** Smooth in Y direction  **/
     1040          for (int colStart = 0; colStart < numCols; colStart+=scanCols) {
     1041              int colStop = PS_MIN (colStart + scanCols, numCols);
     1042
     1043              // allocate a job, construct the arguments for this job
     1044              psThreadJob *job = psThreadJobAlloc("PSLIB_IMAGE_SMOOTHMASK_SCANCOLS");
     1045              psArrayAdd(job->args, 1, output);
     1046              psArrayAdd(job->args, 1, calculation);
     1047              psArrayAdd(job->args, 1, calcMask);
     1048              PS_ARRAY_ADD_SCALAR(job->args, maskVal,  PS_TYPE_U8);
     1049              psArrayAdd(job->args, 1, gaussNorm);
     1050              PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32);
     1051              PS_ARRAY_ADD_SCALAR(job->args, size,     PS_TYPE_S32);
     1052              PS_ARRAY_ADD_SCALAR(job->args, colStart, PS_TYPE_S32);
     1053              PS_ARRAY_ADD_SCALAR(job->args, colStop,  PS_TYPE_S32);
     1054              // -> psImageSmoothMask_ScanCols_F32 (output, calculation, calcMask, maskVal, gauss, minGauss, size, colStart, colStop);
     1055
     1056              // if threading is not active, we simply run the job and return
     1057              if (!psThreadJobAddPending(job)) {
     1058                  psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1059                  psFree(job);
     1060                  return false;
     1061              }
     1062              psFree(job);
     1063          }
     1064
     1065          // wait here for the threaded jobs to finish (NOP if threading is not active)
     1066          if (!psThreadPoolWait(true)) {
     1067              psError(PS_ERR_UNKNOWN, false, "Unable to smooth image");
     1068              return false;
     1069          }
     1070          psFree(calculation);
     1071          psFree(calcMask);
     1072          psFree(gaussNorm);
     1073
     1074          return output;
    10751075      }
    10761076      default:
    … …  
    15071507// XXX for now, either thread all or none
    15081508// have to call this before calling psImageSmoothMask_Threaded
    1509 void psImageConvolveSetThreads(bool set)
    1510 {
     1509bool psImageConvolveSetThreads(bool set)
     1510{
     1511    bool old = threaded;                // Old value
    15111512    if (set && !threaded) {
    15121513        {
    … …  
    15341535    }
    15351536    threaded = set;
     1537    return old;
    15361538}
    15371539

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

    r20462 r20830  
    55 * @author Robert DeSonia, MHPCC
    66 *
    7  * @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    8  * @date $Date: 2008-10-29 20:43:18 $
     7 * @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     8 * @date $Date: 2008-11-26 00:43:12 $
    99 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1010 */
    … …  
    209209
    210210psImage *psImageSmoothMask_Threaded(psImage *output,
    211                                     const psImage *image,
    212                                     const psImage *mask,
    213                                     psMaskType maskVal,
    214                                     float sigma,
    215                                     float numSigma,
    216                                     float minGauss);
     211                                    const psImage *image,
     212                                    const psImage *mask,
     213                                    psMaskType maskVal,
     214                                    float sigma,
     215                                    float numSigma,
     216                                    float minGauss);
    217217
    218218bool psImageSmoothMaskF32(
    … …  
    225225
    226226/// Control threading for image convolution functions
    227 void psImageConvolveSetThreads(bool threaded ///< Run image convolution threaded?
     227///
     228/// Returns old threading status
     229bool psImageConvolveSetThreads(bool threaded ///< Run image convolution threaded?
    228230    );
    229231
Note: See TracChangeset for help on using the changeset viewer.