Changeset 28003 for branches/pap/psLib
- Timestamp:
- May 18, 2010, 12:49:05 PM (16 years ago)
- Location:
- branches/pap
- Files:
-
- 4 edited
-
. (modified) (1 prop)
-
psLib/src/imageops/psImageConvolve.c (modified) (8 diffs)
-
psLib/src/mathtypes/psImage.h (modified) (1 diff)
-
psLib/src/types/psLookupTable.c (modified) (4 diffs)
Legend:
- Unmodified
- Added
- Removed
-
branches/pap
- Property svn:mergeinfo changed
-
branches/pap/psLib/src/imageops/psImageConvolve.c
r26892 r28003 37 37 38 38 39 39 40 static bool threaded = false; // Run image convolution threaded? 40 41 41 static pthread_mutex_t threadMutex = PTHREAD_MUTEX_INITIALIZER; 42 42 43 43 … … 871 871 psFree(job); 872 872 } 873 if (!psThreadPoolWait(true)) { 874 psError(PS_ERR_UNKNOWN, false, "Error waiting for threads."); 875 psFree(gaussNorm); 876 psFree(out); 877 return NULL; 878 } 873 879 } else if (!imageSmoothMaskPixels(out, image, mask, maskVal, x, y, 874 880 gaussNorm, minGauss, size, 0, num)) { 875 881 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.");883 882 psFree(gaussNorm); 884 883 psFree(out); … … 1192 1191 psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */ 1193 1192 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)) { 1214 1225 psError(PS_ERR_UNKNOWN, false, "Unable to smooth image"); 1215 psFree(job); 1226 psFree(calculation); 1227 psFree(calcMask); 1228 psFree(gaussNorm); 1216 1229 return false; 1217 1230 } 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)) { 1224 1233 psError(PS_ERR_UNKNOWN, false, "Unable to smooth image"); 1234 psFree(calculation); 1235 psFree(calcMask); 1236 psFree(gaussNorm); 1225 1237 return false; 1226 1238 } … … 1229 1241 1230 1242 /** 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)) { 1249 1274 psError(PS_ERR_UNKNOWN, false, "Unable to smooth image"); 1250 psFree(job); 1275 psFree(calculation); 1276 psFree(calcMask); 1277 psFree(gaussNorm); 1251 1278 return false; 1252 1279 } 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)) { 1258 1282 psError(PS_ERR_UNKNOWN, false, "Unable to smooth image"); 1283 psFree(calculation); 1284 psFree(calcMask); 1285 psFree(gaussNorm); 1259 1286 return false; 1260 1287 } 1288 1261 1289 psFree(calculation); 1262 1290 psFree(calcMask); … … 1559 1587 psFree(job); 1560 1588 } 1589 if (!psThreadPoolWait(true)) { 1590 psError(PS_ERR_UNKNOWN, false, "Error waiting for threads."); 1591 psFree(conv); 1592 psFree(out); 1593 return NULL; 1594 } 1561 1595 } else if (!imageConvolveMaskColumns(conv, mask, 0, numRows, maskVal, xMin, xMax)) { 1562 1596 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.");1570 1597 psFree(conv); 1571 1598 psFree(out); … … 1597 1624 psFree(job); 1598 1625 } 1626 if (!psThreadPoolWait(true)) { 1627 psError(PS_ERR_UNKNOWN, false, "Error waiting for threads."); 1628 psFree(conv); 1629 psFree(out); 1630 return NULL; 1631 } 1599 1632 } else if (!imageConvolveMaskRows(out, conv, 0, numCols, setVal, yMin, yMax)) { 1600 1633 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.");1608 1634 psFree(conv); 1609 1635 psFree(out); … … 1679 1705 bool psImageConvolveSetThreads(bool set) 1680 1706 { 1707 pthread_mutex_lock(&threadMutex); 1681 1708 bool old = threaded; // Old value 1682 1709 if (set && !threaded) { … … 1711 1738 } 1712 1739 threaded = set; 1740 pthread_mutex_unlock(&threadMutex); 1713 1741 return old; 1714 1742 } -
branches/pap/psLib/src/mathtypes/psImage.h
r19056 r28003 66 66 #define P_PSIMAGE_SET_ROW0(img,r0) {*(int*)&img->row0 = r0;} 67 67 #define P_PSIMAGE_SET_TYPE(img,t) {*(psMathType*)&img->type = t;} 68 #define P_PSIMAGE_GET_TYPE(img) ((img)->type->type) 68 69 69 70 /** Create an image of the specified size and type. -
branches/pap/psLib/src/types/psLookupTable.c
r17447 r28003 31 31 #include "psString.h" 32 32 #include "psError.h" 33 #include "psString.h" 34 #include "psSlurp.h" 33 35 #include "psLookupTable.h" 34 36 … … 153 155 char *end = NULL; \ 154 156 ps##TYPE value = FUNC(strValue, &end, 0); \ 155 if (*end != '\0' && !isspace(*end)) { \ 157 if (*end != '\0' && *end != '\n' && !isspace(*end)) { \ 158 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Characters left over after parsing %s: %s", \ 159 strValue, end); \ 156 160 *status = PS_PARSE_ERROR_VALUE; \ 157 161 } \ … … 164 168 char *end = NULL; \ 165 169 ps##TYPE value = FUNC(strValue, &end); \ 166 if (*end != '\0' && !isspace(*end)) { \ 170 if (*end != '\0' && *end != '\n' && !isspace(*end)) { \ 171 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Characters left over after parsing %s: %s", \ 172 strValue, end); \ 167 173 *status = PS_PARSE_ERROR_VALUE; \ 168 174 } \ … … 244 250 } 245 251 246 psArray *psVectorsReadFromFile(const char *filename, 247 const char *format) 252 psArray *psVectorsReadFromFile(const char *filename, const char *format) 248 253 { 249 254 PS_ASSERT_STRING_NON_EMPTY(filename, NULL); 250 255 PS_ASSERT_STRING_NON_EMPTY(format, NULL); 251 256 252 psArray* outputArray = NULL; 253 psVector* colVector = NULL; 254 char* strValue = NULL; 255 char* strNum = NULL; 256 char* line = NULL; 257 char* linePtr = NULL; 258 int numCols = 0; 259 int numRows = 0; 260 FILE* fp = NULL; 261 const char* tempFormat = NULL; 262 psParseErrorType parseStatus = PS_PARSE_SUCCESS; 263 264 // Create temp pointer which can then be used several times 265 tempFormat = format; 266 267 // Create output array and set array elements to zero 268 outputArray = psArrayAllocEmpty(INITIAL_NUM); 269 270 // Parse the format string to determine how many vectors 271 // and whether the format string is valid 272 while ((strValue = getToken((char**)&tempFormat, " \t", &parseStatus))) { 273 274 // Check for %d format sub string 257 psArray *outputArray = psArrayAllocEmpty(INITIAL_NUM); // Array of vectors to return 258 psParseErrorType parseStatus = PS_PARSE_SUCCESS; // Status of parsing 259 260 // Parse the format string to determine how many vectors and whether the format string is valid 261 const char *tempFormat = format; // Pointer into format 262 psString strValue; // Format of interest 263 int numCols = 0; // Number of columns found in format 264 while ((strValue = getToken((char**)&tempFormat, " \t", &parseStatus)) && 265 parseStatus == PS_PARSE_SUCCESS) { 266 if (strstr(strValue,"\%*") != 0) { 267 // Don't increase number of columns 268 continue; 269 } 270 psElemType type; // Type specified 275 271 if (strcmp(strValue,"\%d") == 0 ) { 276 numCols++; 277 colVector = psVectorAlloc(1,PS_TYPE_S32); 278 outputArray = psArrayAdd(outputArray, ARRAY_STRIDE, colVector); 279 psFree(colVector); 272 type = PS_TYPE_S32; 280 273 } else if (strcmp(strValue,"\%ld") == 0) { 281 numCols++; 282 colVector = psVectorAlloc(1,PS_TYPE_S64); 283 outputArray = psArrayAdd(outputArray, ARRAY_STRIDE, colVector); 284 psFree(colVector); 274 type = PS_TYPE_S64; 285 275 } else if (strcmp(strValue,"\%f") == 0) { 286 numCols++; 287 colVector = psVectorAlloc(1,PS_TYPE_F32); 288 outputArray = psArrayAdd(outputArray, ARRAY_STRIDE, colVector); 289 psFree(colVector); 276 type = PS_TYPE_F32; 290 277 } else if (strcmp(strValue,"\%lf") == 0) { 291 numCols++; 292 colVector = psVectorAlloc(1,PS_TYPE_F64); 293 outputArray = psArrayAdd(outputArray, ARRAY_STRIDE, colVector); 294 psFree(colVector); 295 } else if (strstr(strValue,"\%*") != 0) { 296 // Don't increase number of columns 278 type = PS_TYPE_F64; 297 279 } else { 298 psError(PS_ERR_BAD_PARAMETER_VALUE, true, 299 "Invalid format specifier"); 280 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Invalid format specifier: %s", strValue); 300 281 psFree(strValue); 301 numCols = 0; 302 break; 303 } 282 psFree(outputArray); 283 return NULL; 284 } 285 psVector *colVector = psVectorAllocEmpty(1, type); // Vector for type 286 outputArray = psArrayAdd(outputArray, ARRAY_STRIDE, colVector); 287 psFree(colVector); 288 numCols++; 304 289 psFree(strValue); 290 } 291 if (parseStatus != PS_PARSE_SUCCESS) { 292 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Failed to parse format at column %d: %s", 293 numCols, strValue); 294 psFree(strValue); 295 psFree(outputArray); 296 return NULL; 297 } 298 299 if (numCols == 0) { 300 // Format string parse error detected 301 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Format string was not parsed sucessfully"); 302 psFree(outputArray); 303 return NULL; 305 304 } 306 305 307 306 // If the format string was parsed successfully and return numCols the 308 307 // prepare to open file and read values 309 if (numCols > 0) { 310 311 // Open specified file 312 if ((fp=fopen(filename, "r")) == NULL) { 313 psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to open file %s."), 314 filename); 315 psFree(outputArray); 316 return NULL; 317 } else { 318 // Initialize array index 319 int arrayIndex = 0; 320 321 // Create reusable line for continuous read 322 line = (char*)psAlloc(MAX_STRING_LENGTH*sizeof(char)); 323 324 // Loop through file to get numRows, numCols, and column data types 325 while ((fgets(line, MAX_STRING_LENGTH, fp) != NULL) && 326 (parseStatus == PS_PARSE_SUCCESS)) { 327 328 // Copy pointer to line for parsing 329 linePtr = line; 330 331 // If line is not a comment or blank, then extract data 332 if (!ignoreLine(linePtr)) { 333 numRows++; 334 335 // Copy format pointer for parsing 336 tempFormat = format; 337 arrayIndex = 0; 338 parseStatus = PS_PARSE_SUCCESS; 339 340 // Loop through format and line strings to get values in text table file 341 while ((strValue=getToken((char**)&tempFormat," \t",&parseStatus)) 342 && (strNum=getToken((char**)&linePtr," \t",&parseStatus)) ) { 343 // Set column vector 344 colVector = outputArray->data[arrayIndex]; 345 346 // Set column entries based on format string defining the type 347 if (strcmp(strValue,"\%d") == 0 ) { 348 colVector = psVectorRecycle(colVector, numRows, 349 colVector->type.type); 350 parseValue(colVector,numRows-1,strNum,&parseStatus); 351 arrayIndex++; 352 } else if (strcmp(strValue,"\%ld") == 0) { 353 colVector = psVectorRecycle(colVector, numRows, 354 colVector->type.type); 355 parseValue(colVector,numRows-1,strNum,&parseStatus); 356 arrayIndex++; 357 } else if (strcmp(strValue,"\%f") == 0) { 358 colVector = psVectorRecycle(colVector, numRows, 359 colVector->type.type); 360 parseValue(colVector,numRows-1,strNum,&parseStatus); 361 arrayIndex++; 362 } else if (strcmp(strValue,"\%lf") == 0) { 363 colVector = psVectorRecycle(colVector, numRows, 364 colVector->type.type); 365 parseValue(colVector,numRows-1,strNum,&parseStatus); 366 arrayIndex++; 367 } else if (strstr(strValue,"\%*") != 0) { 368 // Don't increase number of columns 369 } 370 psFree(strValue); 371 psFree(strNum); 372 373 // If the file line was not parsed successful report 374 // error and return NULL 375 if (parseStatus != PS_PARSE_SUCCESS) { 376 psError(PS_ERR_UNKNOWN, true, 377 "Parsing text file failed."); 378 fclose(fp); 379 psFree(outputArray); 380 psFree(line); 381 return NULL; 382 } 383 } 384 if (strValue != NULL && strNum == NULL) { 385 psError(PS_ERR_UNKNOWN, true, 386 "Parsing text file failed - missing table value(s)."); 387 fclose(fp); 388 psFree(outputArray); 389 psFree(line); 390 psFree(strValue); 391 return NULL; 392 } 393 } // ignore line 308 309 psString file = psSlurpFilename(filename); // Contents of file 310 if (!file) { 311 psError(psErrorCodeLast(), false, "Unable to read file of vectors"); 312 psFree(outputArray); 313 return NULL; 314 } 315 316 psArray *lines = psStringSplitArray(file, "\n", false); // Lines of file 317 psFree(file); 318 long numRows = 0; // Number of rows 319 for (long i = 0; i < lines->n; i++) { 320 psString line = lines->data[i]; // Line of interest 321 if (ignoreLine(line)) { 322 continue; 323 } 324 numRows++; 325 326 char *linePtr = line; // Pointer into line 327 328 // Copy format pointer for parsing 329 const char *tempFormat = format; // Pointer into format 330 long arrayIndex = 0; // Index in array 331 parseStatus = PS_PARSE_SUCCESS; 332 333 // Loop through format and line strings to get values in text table file 334 char *strNum; // Number within line 335 while ((strValue=getToken((char**)&tempFormat," \t",&parseStatus)) && 336 (strNum=getToken((char**)&linePtr," \t",&parseStatus)) && 337 parseStatus == PS_PARSE_SUCCESS) { 338 if (strstr(strValue,"\%*") != 0) { 339 continue; 394 340 } 395 341 396 //Return NULL for an empty table 397 if (numRows == 0) { 398 psError(PS_ERR_UNKNOWN, true, 399 "Parsing text file failed - input table is empty."); 400 fclose(fp); 342 // Set column vector 343 psVector *colVector = outputArray->data[arrayIndex]; // Column vector of interest 344 345 outputArray->data[arrayIndex] = colVector = psVectorRecycle(colVector, numRows, 346 colVector->type.type); 347 parseValue(colVector, numRows - 1, strNum, &parseStatus); 348 arrayIndex++; 349 350 if (parseStatus != PS_PARSE_SUCCESS) { 351 psError(PS_ERR_UNKNOWN, false, "Parsing text file failed: %s as %s", strNum, strValue); 401 352 psFree(outputArray); 402 psFree(line); 353 psFree(lines); 354 psFree(strNum); 355 psFree(strValue); 403 356 return NULL; 404 357 } 405 406 // Read on the lines in the file - close file pointer 407 fclose(fp); 408 psFree(line); 409 } 410 } else { 411 // Format string parse error detected 412 psError(PS_ERR_UNKNOWN, true, 413 "Format string was not parsed sucessfully"); 358 psFree(strValue); 359 psFree(strNum); 360 361 } 362 if (strValue != NULL && strNum == NULL) { 363 psError(PS_ERR_UNKNOWN, true, 364 "Parsing text file failed - missing table value(s)."); 365 psFree(outputArray); 366 psFree(lines); 367 psFree(strValue); 368 return NULL; 369 } 370 } 371 if (parseStatus != PS_PARSE_SUCCESS) { 372 psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Failed to parse format at column %d: %s", 373 numCols, strValue); 374 psFree(strValue); 414 375 psFree(outputArray); 415 376 return NULL; 416 377 } 378 379 psFree(lines); 417 380 418 381 // Return populated array
Note:
See TracChangeset
for help on using the changeset viewer.
