IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2273 for trunk/psLib/src/image


Ignore:
Timestamp:
Nov 3, 2004, 3:05:00 PM (22 years ago)
Author:
desonia
Message:

changed the psError signature to match SDRS. Also made misc. cleanups as
I was combing the files.

Location:
trunk/psLib/src/image
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/image/psImage.c

    r2204 r2273  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-10-27 00:57:31 $
     12 *  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-11-04 01:05:00 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4040
    4141    if (area < 1) {
    42         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageAlloc",
    43                    PS_ERR_BAD_PARAMETER_VALUE, true,
    44                    PS_ERRORTEXT_psImage_AREA_NEGATIVE,
    45                    numRows, numCols);
     42        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     43                PS_ERRORTEXT_psImage_AREA_NEGATIVE,
     44                numRows, numCols);
    4645        return NULL;
    4746    }
    … …  
    119118    if (old->type.dimen != PS_DIMEN_IMAGE) {
    120119        psFree(old);
    121         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRecycle",
    122                    PS_ERR_BAD_PARAMETER_TYPE, true,
    123                    PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     120        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     121                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
    124122        return NULL;
    125123    }
    … …  
    175173
    176174    if (input == NULL || input->data.V == NULL) {
    177         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    178                    PS_ERR_BAD_PARAMETER_NULL, true,
    179                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     175        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     176                PS_ERRORTEXT_psImage_IMAGE_NULL);
    180177        psFree(output);
    181178        return NULL;
    … …  
    183180
    184181    if (input == output) {
    185         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    186                    PS_ERR_BAD_PARAMETER_NULL, true,
    187                    PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
     182        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     183                PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
    188184        psFree(output);
    189185        return NULL;
    … …  
    191187
    192188    if (input->type.dimen != PS_DIMEN_IMAGE) {
    193         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    194                    PS_ERR_BAD_PARAMETER_TYPE, true,
    195                    PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     189        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     190                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
    196191        psFree(output);
    197192        return NULL;
    … …  
    205200
    206201    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
    207         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    208                    PS_ERR_BAD_PARAMETER_TYPE, true,
    209                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    210                    PS_TYPE_PTR_NAME);
     202        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     203                PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     204                PS_TYPE_PTR_NAME);
    211205        psFree(output);
    212206        return NULL;
    … …  
    319313            char* typeStr;
    320314            PS_TYPE_NAME(typeStr,type);
    321             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
    322                        PS_ERR_BAD_PARAMETER_TYPE, true,
    323                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    324                        typeStr);
     315            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     316                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     317                    typeStr);
    325318            psFree(output);
    326319
    … …  
    372365
    373366    if (input == NULL) {
    374         psErrorMsg(PS_ERRORNAME_DOMAIN "psImagePixelInterpolate",
    375                    PS_ERR_BAD_PARAMETER_NULL,true,
    376                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     367        psError(PS_ERR_BAD_PARAMETER_NULL,true,
     368                PS_ERRORTEXT_psImage_IMAGE_NULL);
    377369        return unexposedValue;
    378370    }
    … …  
    400392        break;                                                       \
    401393    default:                                                         \
    402         psErrorMsg(PS_ERRORNAME_DOMAIN "psImagePixelInterpolate",    \
    403                    PS_ERR_BAD_PARAMETER_VALUE,true,                  \
    404                    PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID,  \
    405                    mode);                                            \
     394        psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
     395                PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID,     \
     396                mode);                                               \
    406397    }                                                                \
    407398    break
    … …  
    423414            char* typeStr;
    424415            PS_TYPE_NAME(typeStr,input->type.type);
    425             psErrorMsg(PS_ERRORNAME_DOMAIN "psImagePixelInterpolate",
    426                        PS_ERR_BAD_PARAMETER_TYPE,true,
    427                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    428                        typeStr);
     416            psError(PS_ERR_BAD_PARAMETER_TYPE,true,
     417                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     418                    typeStr);
    429419        }
    430420    }

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

    r2204 r2273  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-10-27 00:57:31 $
     7 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-11-04 01:05:00 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    110110    // got non-NULL vectors?
    111111    if (tShifts == NULL || xShifts == NULL || yShifts == NULL) {
    112         psErrorMsg(PS_ERRORNAME_DOMAIN "psKernelGenerate",
    113                    PS_ERR_BAD_PARAMETER_NULL, true,
    114                    PS_ERRORTEXT_psImageConvolve_SHIFT_NULL);
     112        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     113                PS_ERRORTEXT_psImageConvolve_SHIFT_NULL);
    115114        return NULL;
    116115    }
    … …  
    125124        PS_TYPE_NAME(typeYStr,yShifts->type.type);
    126125        PS_TYPE_NAME(typeTStr,tShifts->type.type);
    127         psErrorMsg(PS_ERRORNAME_DOMAIN "psKernelGenerate",
    128                    PS_ERR_BAD_PARAMETER_TYPE, true,
    129                    PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH,
    130                    typeTStr, typeXStr, typeYStr);
     126        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     127                PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH,
     128                typeTStr, typeXStr, typeYStr);
    131129        return NULL;
    132130    }
    … …  
    218216            char* typeStr;
    219217            PS_TYPE_NAME(typeStr,xShifts->type.type);
    220             psErrorMsg(PS_ERRORNAME_DOMAIN "psKernelGenerate",
    221                        PS_ERR_BAD_PARAMETER_TYPE, true,
    222                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    223                        typeStr);
     218            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     219                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     220                    typeStr);
    224221        }
    225222    }
    … …  
    236233
    237234    if (kernel == NULL) {
    238         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    239                    PS_ERR_BAD_PARAMETER_NULL, true,
    240                    PS_ERRORTEXT_psImageConvolve_KERNEL_NULL);
     235        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     236                PS_ERRORTEXT_psImageConvolve_KERNEL_NULL);
    241237        psFree(out);
    242238        return NULL;
    … …  
    297293                char* typeStr;
    298294                PS_TYPE_NAME(typeStr,in->type.type);
    299                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    300                            PS_ERR_BAD_PARAMETER_TYPE, true,
    301                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    302                            typeStr);
     295                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     296                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     297                        typeStr);
    303298                psFree(out);
    304299                return NULL;
    … …  
    317312        psS32 kCols = kernel->image->numCols;
    318313        if (kRows >= numRows || kCols >= numCols) {
    319             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    320                        PS_ERR_BAD_PARAMETER_SIZE, true,
    321                        PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE,
    322                        kCols,kRows,
    323                        numCols, numRows);
     314            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
     315                    PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE,
     316                    kCols,kRows,
     317                    numCols, numRows);
    324318            psFree(out);
    325319            return NULL;
    … …  
    376370        psImage* kernelFourier = psImageFFT(NULL, paddedKernel, PS_FFT_FORWARD);
    377371        if (kernelFourier == NULL) {
    378             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    379                        PS_ERR_UNKNOWN, false,
    380                        PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED);
     372            psError(PS_ERR_UNKNOWN, false,
     373                    PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED);
    381374            psFree(out);
    382375            return NULL;
    … …  
    385378        psImage* inFourier = psImageFFT(NULL, paddedImage, PS_FFT_FORWARD);
    386379        if (inFourier == NULL) {
    387             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    388                        PS_ERR_UNKNOWN, false,
    389                        PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
     380            psError(PS_ERR_UNKNOWN, false,
     381                    PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
    390382            psFree(out);
    391383            return NULL;
    … …  
    398390                                         PS_FFT_REVERSE);
    399391        if (complexOut == NULL) {
    400             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
    401                        PS_ERR_UNKNOWN, false,
    402                        PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
     392            psError(PS_ERR_UNKNOWN, false,
     393                    PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
    403394            psFree(out);
    404395            return NULL;

  • trunk/psLib/src/image/psImageExtraction.c

    r2204 r2273  
    99 *  @author Robert DeSonia, MHPCC
    1010 *
    11  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-10-27 00:57:31 $
     11 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-11-04 01:05:00 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3535
    3636    if (image == NULL || image->data.V == NULL) {
    37         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubset",
    38                    PS_ERR_BAD_PARAMETER_NULL, true,
    39                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     37        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     38                PS_ERRORTEXT_psImage_IMAGE_NULL);
    4039        return NULL;
    4140    }
    4241
    4342    if (image->type.dimen != PS_DIMEN_IMAGE) {
    44         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubset",
    45                    PS_ERR_BAD_PARAMETER_TYPE, true,
    46                    PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     43        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     44                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
    4745        return NULL;
    4846    }
    … …  
    6159            col1 > image->numCols ||
    6260            row1 > image->numRows ) {
    63         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubset",
    64                    PS_ERR_BAD_PARAMETER_VALUE, true,
    65                    PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    66                    col0, col1-1, row0, row1-1,
    67                    image->numCols-1, image->numRows-1);
     61        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     62                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     63                col0, col1-1, row0, row1-1,
     64                image->numCols-1, image->numRows-1);
    6865        return NULL;
    6966    }
    … …  
    152149    // section should be of the form '[col0:col1,row0:row1]'
    153150    if (section == NULL) {
    154         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubsection",
    155                    PS_ERR_BAD_PARAMETER_NULL, true,
    156                    PS_ERRORTEXT_psImage_SUBSECTION_NULL);
     151        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     152                PS_ERRORTEXT_psImage_SUBSECTION_NULL);
    157153        return NULL;
    158154    }
    159155
    160156    if (sscanf(section,"[%d:%d,%d:%d]",&col0,&col1,&row0,&row1) < 4) {
    161         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubsection",
    162                    PS_ERR_BAD_PARAMETER_NULL, true,
    163                    PS_ERRORTEXT_psImage_SUBSECTION_INVALID,
    164                    section);
     157        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     158                PS_ERRORTEXT_psImage_SUBSECTION_INVALID,
     159                section);
    165160        return NULL;
    166161    }
    167162
    168163    if (col0 > col1 || row0 > row1) {
    169         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSubsection",
    170                    PS_ERR_BAD_PARAMETER_VALUE, true,
    171                    PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
    172                    col0,col1,row0,row1);
     164        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     165                PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
     166                col0,col1,row0,row1);
    173167        return NULL;
    174168    }
    … …  
    180174{
    181175    if (image == NULL || image->data.V == NULL) {
    182         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageTrim",
    183                    PS_ERR_BAD_PARAMETER_NULL, true,
    184                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     176        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     177                PS_ERRORTEXT_psImage_IMAGE_NULL);
    185178        return NULL;
    186179    }
    … …  
    209202            col0 >= col1 ||
    210203            row0 >= row1 ) {
    211         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageTrim",
    212                    PS_ERR_BAD_PARAMETER_VALUE, true,
    213                    PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    214                    col0, col1-1, row0, row1-1,
    215                    image->numCols-1, image->numRows-1);
     204        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     205                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     206                col0, col1-1, row0, row1-1,
     207                image->numCols-1, image->numRows-1);
    216208        psFree(image);
    217209        return NULL;
    … …  
    267259
    268260    if (in == NULL || in->data.V == NULL) {
    269         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    270                    PS_ERR_BAD_PARAMETER_NULL, true,
    271                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     261        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     262                PS_ERRORTEXT_psImage_IMAGE_NULL);
    272263        psFree(out);
    273264        return NULL;
    … …  
    288279            col0 >= col1 ||
    289280            row0 >= row1) {
    290         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    291                    PS_ERR_BAD_PARAMETER_VALUE, true,
    292                    PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    293                    col0, col1, row0, row1,
    294                    in->numCols, in->numRows);
     281        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     282                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     283                col0, col1, row0, row1,
     284                in->numCols, in->numRows);
    295285        psFree(out);
    296286        return NULL;
    … …  
    307297    if (mask != NULL) {
    308298        if (inRows != mask->numRows || inCols != mask->numCols) {
    309             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    310                        PS_ERR_BAD_PARAMETER_VALUE, true,
    311                        PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
    312                        mask->numCols,mask->numRows,
    313                        inCols, inRows);
     299            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     300                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     301                    mask->numCols,mask->numRows,
     302                    inCols, inRows);
    314303            psFree(out);
    315304            return NULL;
    … …  
    318307            char* typeStr;
    319308            PS_TYPE_NAME(typeStr,mask->type.type);
    320             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    321                        PS_ERR_BAD_PARAMETER_TYPE, true,
    322                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    323                        typeStr, PS_TYPE_MASK_NAME);
     309            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     310                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     311                    typeStr, PS_TYPE_MASK_NAME);
    324312            psFree(out);
    325313            return NULL;
    … …  
    328316
    329317    if (stats == NULL) {
    330         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    331                    PS_ERR_BAD_PARAMETER_NULL, true,
    332                    PS_ERRORTEXT_psImage_STAT_NULL);
     318        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     319                PS_ERRORTEXT_psImage_STAT_NULL);
    333320        psFree(out);
    334321        return NULL;
    … …  
    338325    // single stats operation
    339326    if (p_psGetStatValue(stats, &statVal) == false) {
    340         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    341                    PS_ERR_BAD_PARAMETER_VALUE, false,
    342                    PS_ERRORTEXT_psImage_BAD_STAT,stats->options);
     327        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     328                PS_ERRORTEXT_psImage_BAD_STAT,stats->options);
    343329        psFree(out);
    344330        return NULL;
    … …  
    423409                char* typeStr;
    424410                PS_TYPE_NAME(typeStr,type);
    425                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    426                            PS_ERR_BAD_PARAMETER_TYPE, true,
    427                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    428                            typeStr);
     411                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     412                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     413                        typeStr);
    429414                psFree(out);
    430415                out = NULL;
    … …  
    485470        psFree(maskVec);
    486471    } else { // don't know what the direction flag is
    487         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageSlice",
    488                    PS_ERR_BAD_PARAMETER_VALUE, true,
    489                    PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID,
    490                    direction);
     472        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     473                PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID,
     474                direction);
    491475        psFree(out);
    492476        out = NULL;
    … …  
    512496{
    513497    if (in == NULL || in->data.V == NULL) {
    514         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    515                    PS_ERR_BAD_PARAMETER_NULL, true,
    516                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     498        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     499                PS_ERRORTEXT_psImage_IMAGE_NULL);
    517500        psFree(out);
    518501        return NULL;
    … …  
    522505
    523506    if (nSamples < 2) {
    524         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    525                    PS_ERR_BAD_PARAMETER_VALUE, true,
    526                    PS_ERRORTEXT_psImage_nSamples_TOOSMALL,
    527                    nSamples);
     507        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     508                PS_ERRORTEXT_psImage_nSamples_TOOSMALL,
     509                nSamples);
    528510        psFree(out);
    529511        return NULL;
    … …  
    534516            endCol < 0 || endCol >= numCols ||
    535517            endRow < 0 || endRow >= numRows) {
    536         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    537                    PS_ERR_BAD_PARAMETER_VALUE, true,
    538                    PS_ERRORTEXT_psImage_LINE_NOT_IN_IMAGE,
    539                    startCol,startRow,endCol,endRow,
    540                    numCols-1,numRows-1);
     518        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     519                PS_ERRORTEXT_psImage_LINE_NOT_IN_IMAGE,
     520                startCol,startRow,endCol,endRow,
     521                numCols-1,numRows-1);
    541522        psFree(out);
    542523        return NULL;
    … …  
    544525
    545526    if (mode < PS_INTERPOLATE_FLAT || mode >= PS_INTERPOLATE_NUM_MODES) {
    546         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageResample",
    547                    PS_ERR_BAD_PARAMETER_VALUE, true,
    548                    PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
    549                    mode);
     527        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     528                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     529                mode);
    550530        psFree(out);
    551531        return NULL;
    … …  
    554534    if (mask != NULL) {
    555535        if (numRows != mask->numRows || numCols != mask->numCols) {
    556             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    557                        PS_ERR_BAD_PARAMETER_VALUE, true,
    558                        PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
    559                        mask->numCols,mask->numRows,
    560                        numCols-1, numRows);
     536            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     537                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     538                    mask->numCols,mask->numRows,
     539                    numCols-1, numRows);
    561540            psFree(out);
    562541            return NULL;
    … …  
    565544            char* typeStr;
    566545            PS_TYPE_NAME(typeStr,mask->type.type);
    567             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    568                        PS_ERR_BAD_PARAMETER_TYPE, true,
    569                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    570                        typeStr, PS_TYPE_MASK_NAME);
     546            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     547                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     548                    typeStr, PS_TYPE_MASK_NAME);
    571549            psFree(out);
    572550            return NULL;
    … …  
    627605            char* typeStr;
    628606            PS_TYPE_NAME(typeStr,in->type.type);
    629             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCut",
    630                        PS_ERR_BAD_PARAMETER_TYPE, true,
    631                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    632                        typeStr);
     607            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     608                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     609                    typeStr);
    633610            psFree(out);
    634611            out = NULL;
    … …  
    653630
    654631    if (in == NULL || in->data.V == NULL) {
    655         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    656                    PS_ERR_BAD_PARAMETER_NULL, true,
    657                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     632        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     633                PS_ERRORTEXT_psImage_IMAGE_NULL);
    658634        psFree(out);
    659635        return NULL;
    … …  
    664640    if (mask != NULL) {
    665641        if (numRows != mask->numRows || numCols != mask->numCols) {
    666             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    667                        PS_ERR_BAD_PARAMETER_SIZE, true,
    668                        PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
    669                        mask->numCols,mask->numRows,
    670                        numCols, numRows);
     642            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
     643                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     644                    mask->numCols,mask->numRows,
     645                    numCols, numRows);
    671646            psFree(out);
    672647            return NULL;
    … …  
    675650            char* typeStr;
    676651            PS_TYPE_NAME(typeStr,mask->type.type);
    677             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    678                        PS_ERR_BAD_PARAMETER_TYPE, true,
    679                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    680                        typeStr, PS_TYPE_MASK_NAME);
     652            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     653                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     654                    typeStr, PS_TYPE_MASK_NAME);
    681655            psFree(out);
    682656            return NULL;
    … …  
    686660    if (centerCol < 0 || centerCol >= numCols ||
    687661            centerRow < 0 || centerRow >= numRows) {
    688         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    689                    PS_ERR_BAD_PARAMETER_VALUE, true,
    690                    PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
    691                    centerCol, centerRow,
    692                    numCols-1, numRows-1);
     662        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     663                PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
     664                centerCol, centerRow,
     665                numCols-1, numRows-1);
    693666        psFree(out);
    694667        return NULL;
    … …  
    696669
    697670    if (radii == NULL) {
    698         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    699                    PS_ERR_BAD_PARAMETER_NULL, true,
    700                    PS_ERRORTEXT_psImage_RADII_VECTOR_NULL);
     671        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     672                PS_ERRORTEXT_psImage_RADII_VECTOR_NULL);
    701673        psFree(out);
    702674        return NULL;
    … …  
    704676
    705677    if (radii->n < 2) {
    706         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    707                    PS_ERR_BAD_PARAMETER_SIZE, true,
    708                    PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL,
    709                    radii->n);
     678        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
     679                PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL,
     680                radii->n);
    710681        psFree(out);
    711682        return NULL;
    … …  
    713684
    714685    if (stats == NULL) {
    715         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    716                    PS_ERR_BAD_PARAMETER_NULL, true,
    717                    PS_ERRORTEXT_psImage_STAT_NULL);
     686        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     687                PS_ERRORTEXT_psImage_STAT_NULL);
    718688        psFree(out);
    719689        return NULL;
    … …  
    723693    // single stats operation
    724694    if (p_psGetStatValue(stats, &statVal) == false) {
    725         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRadialCut",
    726                    PS_ERR_BAD_PARAMETER_VALUE, false,
    727                    PS_ERRORTEXT_psImage_BAD_STAT,
    728                    stats->options);
     695        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     696                PS_ERRORTEXT_psImage_BAD_STAT,
     697                stats->options);
    729698        psFree(out);
    730699        return NULL;

  • trunk/psLib/src/image/psImageFFT.c

    r2204 r2273  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-10-27 00:57:31 $
     7 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-11-04 01:05:00 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4343    if ( ((direction & PS_FFT_FORWARD) != 0) ) {
    4444        if ((direction & PS_FFT_REVERSE) != 0) {
    45             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFFT",
    46                        PS_ERR_BAD_PARAMETER_VALUE, true,
    47                        PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE);
     45            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     46                    PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE);
    4847            psFree(out);
    4948            return NULL;
    5049        }
    5150        if ((direction & PS_FFT_REAL_RESULT) != 0) {
    52             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFFT",
    53                        PS_ERR_BAD_PARAMETER_VALUE, true,
    54                        PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED);
     51            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     52                    PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED);
    5553            psFree(out);
    5654            return NULL;
    5755        }
    5856    } else if ((direction & PS_FFT_REVERSE) == 0) {
    59         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFFT",
    60                    PS_ERR_BAD_PARAMETER_VALUE, true,
    61                    PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION);
     57        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     58                PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION);
    6259        psFree(out);
    6360        return NULL;
    … …  
    8683    /* check if a plan exists now -- if not, it is a real problem at this point */
    8784    if (plan == NULL) {
    88         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFFT",
    89                    PS_ERR_BAD_PARAMETER_TYPE, true,
    90                    PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL);
     85        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     86                PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL);
    9187        psFree(out);
    9288        return NULL;
    … …  
    163159        char* typeStr;
    164160        PS_TYPE_NAME(typeStr,type);
    165         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReal",
    166                    PS_ERR_BAD_PARAMETER_TYPE, true,
    167                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    168                    typeStr);
     161        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     162                PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     163                typeStr);
    169164
    170165        psFree(out);
    … …  
    226221        char* typeStr;
    227222        PS_TYPE_NAME(typeStr,type);
    228         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageImaginary",
    229                    PS_ERR_BAD_PARAMETER_TYPE, true,
    230                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    231                    typeStr);
     223        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     224                PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     225                typeStr);
    232226        psFree(out);
    233227        return NULL;
    … …  
    257251        PS_TYPE_NAME(typeStrReal,type);
    258252        PS_TYPE_NAME(typeStrImag,imag->type.type);
    259         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageComplex",
    260                    PS_ERR_BAD_PARAMETER_TYPE, true,
    261                    PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH,
    262                    typeStrReal,typeStrImag);
     253        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     254                PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH,
     255                typeStrReal,typeStrImag);
    263256        psFree(out);
    264257        return NULL;
    … …  
    266259
    267260    if (imag->numCols != numCols || imag->numRows != numRows) {
    268         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageComplex",
    269                    PS_ERR_BAD_PARAMETER_VALUE, true,
    270                    PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH,
    271                    numCols, numRows, imag->numCols, imag->numRows);
     261        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     262                PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH,
     263                numCols, numRows, imag->numCols, imag->numRows);
    272264        psFree(out);
    273265        return NULL;
    … …  
    308300        char* typeStr;
    309301        PS_TYPE_NAME(typeStr,type);
    310         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageComplex",
    311                    PS_ERR_BAD_PARAMETER_TYPE, true,
    312                    PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED,
    313                    typeStr);
     302        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     303                PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED,
     304                typeStr);
    314305        psFree(out);
    315306        return NULL;
    … …  
    369360        char* typeStr;
    370361        PS_TYPE_NAME(typeStr,type);
    371         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConjugate",
    372                    PS_ERR_BAD_PARAMETER_TYPE, true,
    373                    PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
    374                    typeStr);
     362        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     363                PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
     364                typeStr);
    375365        psFree(out);
    376366        return NULL;
    … …  
    434424        char* typeStr;
    435425        PS_TYPE_NAME(typeStr,type);
    436         psErrorMsg(PS_ERRORNAME_DOMAIN "psImagePowerSpectrum",
    437                    PS_ERR_BAD_PARAMETER_TYPE, true,
    438                    PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
    439                    typeStr);
    440         psFree(out);
    441         return NULL;
    442     }
    443 
    444     return out;
    445 
    446 }
     426        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     427                PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
     428                typeStr);
     429        psFree(out);
     430        return NULL;
     431    }
     432
     433    return out;
     434
     435}

  • trunk/psLib/src/image/psImageIO.c

    r2210 r2273  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-10-27 19:35:58 $
     9 *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-11-04 01:05:00 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4747
    4848    if (filename == NULL) {
    49         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    50                    PS_ERR_BAD_PARAMETER_NULL, true,
    51                    PS_ERRORTEXT_psImageIO_FILENAME_NULL);
     49        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     50                PS_ERRORTEXT_psImageIO_FILENAME_NULL);
    5251        psFree(output);
    5352        return NULL;
    … …  
    5857    if (fptr == NULL || status != 0) {
    5958        fits_get_errstatus(status, fitsErr);
    60         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    61                    PS_ERR_BAD_PARAMETER_VALUE, true,
    62                    PS_ERRORTEXT_psImageIO_FILENAME_INVALID,
    63                    filename, fitsErr);
     59        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     60                PS_ERRORTEXT_psImageIO_FILENAME_INVALID,
     61                filename, fitsErr);
    6462        psFree(output);
    6563        return NULL;
    … …  
    7270            status = 0;
    7371            (void)fits_close_file(fptr, &status);
    74             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    75                        PS_ERR_LOCATION_INVALID, true,
    76                        PS_ERRORTEXT_psImageIO_EXTNAME_INVALID,
    77                        extname, filename, fitsErr);
     72            psError(PS_ERR_LOCATION_INVALID, true,
     73                    PS_ERRORTEXT_psImageIO_EXTNAME_INVALID,
     74                    extname, filename, fitsErr);
    7875            psFree(output);
    7976            return NULL;
    … …  
    8481            status = 0;
    8582            (void)fits_close_file(fptr, &status);
    86             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    87                        PS_ERR_LOCATION_INVALID, true,
    88                        PS_ERRORTEXT_psImageIO_EXTNUM_INVALID,
    89                        extnum, filename, fitsErr);
     83            psError(PS_ERR_LOCATION_INVALID, true,
     84                    PS_ERRORTEXT_psImageIO_EXTNUM_INVALID,
     85                    extnum, filename, fitsErr);
    9086            psFree(output);
    9187            return NULL;
    … …  
    9894        status = 0;
    9995        (void)fits_close_file(fptr, &status);
    100         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    101                    PS_ERR_IO, true,
    102                    PS_ERRORTEXT_psImageIO_DATATYPE_UNKNOWN,
    103                    filename, fitsErr);
     96        psError(PS_ERR_IO, true,
     97                PS_ERRORTEXT_psImageIO_DATATYPE_UNKNOWN,
     98                filename, fitsErr);
    10499        psFree(output);
    105100        return NULL;
    … …  
    111106        status = 0;
    112107        (void)fits_close_file(fptr, &status);
    113         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    114                    PS_ERR_IO, true,
    115                    PS_ERRORTEXT_psImageIO_IMAGE_DIM_UNKNOWN,
    116                    filename, fitsErr);
     108        psError(PS_ERR_IO, true,
     109                PS_ERRORTEXT_psImageIO_IMAGE_DIM_UNKNOWN,
     110                filename, fitsErr);
    117111        psFree(output);
    118112        return NULL;
    … …  
    123117        status = 0;
    124118        (void)fits_close_file(fptr, &status);
    125         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    126                    PS_ERR_IO, true,
    127                    PS_ERRORTEXT_psImageIO_IMAGE_DIMENSION_UNSUPPORTED,
    128                    nAxis);
     119        psError(PS_ERR_IO, true,
     120                PS_ERRORTEXT_psImageIO_IMAGE_DIMENSION_UNSUPPORTED,
     121                nAxis);
    129122        psFree(output);
    130123        return NULL;
    … …  
    136129        status = 0;
    137130        (void)fits_close_file(fptr, &status);
    138         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    139                    PS_ERR_IO, true,
    140                    PS_ERRORTEXT_psImageIO_IMAGE_SIZE_UNKNOWN,
    141                    filename, fitsErr);
     131        psError(PS_ERR_IO, true,
     132                PS_ERRORTEXT_psImageIO_IMAGE_SIZE_UNKNOWN,
     133                filename, fitsErr);
    142134        psFree(output);
    143135        return NULL;
    … …  
    201193        break;
    202194    default:
    203         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    204                    PS_ERR_IO, true,
    205                    PS_ERRORTEXT_psImageIO_FITS_TYPE_UNSUPPORTED,
    206                    bitPix, filename);
     195        psError(PS_ERR_IO, true,
     196                PS_ERRORTEXT_psImageIO_FITS_TYPE_UNSUPPORTED,
     197                bitPix, filename);
    207198        psFree(output);
    208199        return NULL;
    … …  
    215206        status = 0;
    216207        (void)fits_close_file(fptr, &status);
    217         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageReadSection",
    218                    PS_ERR_IO, true,
    219                    PS_ERRORTEXT_psImageIO_READ_FAILED,
    220                    filename, fitsErr);
     208        psError(PS_ERR_IO, true,
     209                PS_ERRORTEXT_psImageIO_READ_FAILED,
     210                filename, fitsErr);
    221211        return NULL;
    222212    }
    … …  
    253243    /* need a valid image to write */
    254244    if (input == NULL) {
    255         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    256                    PS_ERR_BAD_PARAMETER_NULL, true,
    257                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     245        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     246                PS_ERRORTEXT_psImage_IMAGE_NULL);
    258247        return false;
    259248    }
    … …  
    301290            char* typeStr;
    302291            PS_TYPE_NAME(typeStr,input->type.type);
    303             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    304                        PS_ERR_BAD_PARAMETER_TYPE, true,
    305                        PS_ERRORTEXT_psImageIO_TYPE_UNSUPPORTED,
    306                        typeStr);
     292            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     293                    PS_ERRORTEXT_psImageIO_TYPE_UNSUPPORTED,
     294                    typeStr);
    307295            return false;
    308296        }
    … …  
    315303        if (fptr == NULL || status != 0) {
    316304            fits_get_errstatus(status, fitsErr);
    317             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    318                        PS_ERR_BAD_PARAMETER_VALUE, true,
    319                        PS_ERRORTEXT_psImageIO_FILENAME_INVALID,
    320                        filename, fitsErr);
     305            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     306                    PS_ERRORTEXT_psImageIO_FILENAME_INVALID,
     307                    filename, fitsErr);
    321308            return false;
    322309        }
    … …  
    328315                status = 0;
    329316                (void)fits_close_file(fptr, &status);
    330                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    331                            PS_ERR_LOCATION_INVALID, true,
    332                            PS_ERRORTEXT_psImageIO_EXTNAME_INVALID,
    333                            extname, filename, fitsErr);
     317                psError(PS_ERR_LOCATION_INVALID, true,
     318                        PS_ERRORTEXT_psImageIO_EXTNAME_INVALID,
     319                        extname, filename, fitsErr);
    334320                return false;
    335321            }
    … …  
    341327                status = 0;
    342328                (void)fits_close_file(fptr, &status);
    343                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    344                            PS_ERR_LOCATION_INVALID, true,
    345                            PS_ERRORTEXT_psImageIO_WRITE_EXTNUM_INVALID,
    346                            extnum, numHDUs);
     329                psError(PS_ERR_LOCATION_INVALID, true,
     330                        PS_ERRORTEXT_psImageIO_WRITE_EXTNUM_INVALID,
     331                        extnum, numHDUs);
    347332                return false;
    348333            } else if (numHDUs == extnum) {
    … …  
    352337                status = 0;
    353338                (void)fits_close_file(fptr, &status);
    354                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    355                            PS_ERR_LOCATION_INVALID, true,
    356                            PS_ERRORTEXT_psImageIO_EXTNUM_INVALID,
    357                            extnum, filename, fitsErr);
     339                psError(PS_ERR_LOCATION_INVALID, true,
     340                        PS_ERRORTEXT_psImageIO_EXTNUM_INVALID,
     341                        extnum, filename, fitsErr);
    358342                return false;
    359343            }
    … …  
    368352        if (fptr == NULL || status != 0) {
    369353            fits_get_errstatus(status, fitsErr);
    370             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    371                        PS_ERR_IO, true,
    372                        PS_ERRORTEXT_psImageIO_FILENAME_CREATE_FAILED,
    373                        filename, fitsErr);
     354            psError(PS_ERR_IO, true,
     355                    PS_ERRORTEXT_psImageIO_FILENAME_CREATE_FAILED,
     356                    filename, fitsErr);
    374357            return false;
    375358        }
    … …  
    386369            status = 0;
    387370            (void)fits_close_file(fptr, &status);
    388             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    389                        PS_ERR_IO, true,
    390                        PS_ERRORTEXT_psImageIO_CREATE_HDU_FAILED,
    391                        filename, fitsErr);
     371            psError(PS_ERR_IO, true,
     372                    PS_ERRORTEXT_psImageIO_CREATE_HDU_FAILED,
     373                    filename, fitsErr);
    392374            return false;
    393375        }
    … …  
    403385                status = 0;
    404386                (void)fits_close_file(fptr, &status);
    405                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    406                            PS_ERR_IO, true,
    407                            PS_ERRORTEXT_psImageIO_CREATE_EXTENSION_FAILED,
    408                            filename, fitsErr);
     387                psError(PS_ERR_IO, true,
     388                        PS_ERRORTEXT_psImageIO_CREATE_EXTENSION_FAILED,
     389                        filename, fitsErr);
    409390                return false;
    410391            }
    … …  
    424405        status = 0;
    425406        (void)fits_close_file(fptr, &status);
    426         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageWriteSection",
    427                    PS_ERR_IO, true,
    428                    PS_ERRORTEXT_psImageIO_WRITE_FAILED,
    429                    filename, fitsErr);
     407        psError(PS_ERR_IO, true,
     408                PS_ERRORTEXT_psImageIO_WRITE_FAILED,
     409                filename, fitsErr);
    430410        return false;
    431411    }

  • trunk/psLib/src/image/psImageManip.c

    r2204 r2273  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2004-10-27 00:57:31 $
     12 *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2004-11-04 01:05:00 $
    1414 *
    1515 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4343
    4444    if (max < min) {
    45         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip",
    46                    PS_ERR_BAD_PARAMETER_VALUE, true,
    47                    PS_ERRORTEXT_psImageManip_MAXMIN,
    48                    (double)min,(double)max);
     45        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     46                PS_ERRORTEXT_psImageManip_MAXMIN,
     47                (double)min,(double)max);
    4948        return 0;
    5049    }
    … …  
    5857    case PS_TYPE_##type: { \
    5958            if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
    60                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip", \
    61                            PS_ERR_BAD_PARAMETER_VALUE, true, \
    62                            PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
    63                            "vmin",vmin, PS_TYPE_##type##_NAME, \
    64                            (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
     59                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     60                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     61                        "vmin",vmin, PS_TYPE_##type##_NAME, \
     62                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    6563            } \
    6664            if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
    67                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip", \
    68                            PS_ERR_BAD_PARAMETER_VALUE, true, \
    69                            PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
    70                            "vmax",vmax, PS_TYPE_##type##_NAME, \
    71                            (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
     65                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     66                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     67                        "vmax",vmax, PS_TYPE_##type##_NAME, \
     68                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    7269            } \
    7370            for (psU32 row = 0;row<numRows;row++) { \
    … …  
    8986    case PS_TYPE_##type: { \
    9087            if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
    91                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip", \
    92                            PS_ERR_BAD_PARAMETER_VALUE, true, \
    93                            PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
    94                            "vmin",vmin, PS_TYPE_##type##_NAME, \
    95                            (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
     88                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     89                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     90                        "vmin",vmin, PS_TYPE_##type##_NAME, \
     91                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    9692            } \
    9793            if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
    98                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip", \
    99                            PS_ERR_BAD_PARAMETER_VALUE, true, \
    100                            PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
    101                            "vmax",vmax, PS_TYPE_##type##_NAME, \
    102                            (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
     94                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     95                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     96                        "vmax",vmax, PS_TYPE_##type##_NAME, \
     97                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    10398            } \
    10499            for (psU32 row = 0;row<numRows;row++) { \
    … …  
    133128            char* typeStr;
    134129            PS_TYPE_NAME(typeStr,input->type.type);
    135             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClip",
    136                        PS_ERR_BAD_PARAMETER_TYPE, true,
    137                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    138                        typeStr);
     130            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     131                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     132                    typeStr);
    139133        }
    140134    }
    … …  
    179173            char* typeStr;
    180174            PS_TYPE_NAME(typeStr,input->type.type);
    181             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipNaN",
    182                        PS_ERR_BAD_PARAMETER_TYPE, true,
    183                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    184                        typeStr);
     175            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     176                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     177                    typeStr);
    185178        }
    186179    }
    … …  
    204197
    205198    if (image == NULL || overlay == NULL) {
    206         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection",
    207                    PS_ERR_BAD_PARAMETER_NULL, true,
    208                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     199        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     200                PS_ERRORTEXT_psImage_IMAGE_NULL);
    209201        return 1;
    210202    }
    211203
    212204    if (op == NULL) {
    213         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection",
    214                    PS_ERR_BAD_PARAMETER_NULL, true,
    215                    PS_ERRORTEXT_psImageManip_OPERATION_NULL);
     205        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     206                PS_ERRORTEXT_psImageManip_OPERATION_NULL);
    216207        return 1;
    217208    }
    … …  
    224215        PS_TYPE_NAME(typeStr,type);
    225216        PS_TYPE_NAME(typeStrOverlay,overlay->type.type);
    226         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection",
    227                    PS_ERR_BAD_PARAMETER_TYPE, true,
    228                    PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH,
    229                    typeStrOverlay, typeStr);
     217        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     218                PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH,
     219                typeStrOverlay, typeStr);
    230220        return 2;
    231221    }
    … …  
    244234            imageColLimit > imageNumCols) {
    245235
    246         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection",
    247                    PS_ERR_BAD_PARAMETER_VALUE, true,
    248                    PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
    249                    col0, imageColLimit, row0, imageRowLimit,
    250                    imageNumCols, imageNumRows);
     236        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     237                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     238                col0, imageColLimit, row0, imageRowLimit,
     239                imageNumCols, imageNumRows);
    251240        return 3;
    252241    }
    … …  
    277266                    break; \
    278267                default: \
    279                     psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection", \
    280                                PS_ERR_BAD_PARAMETER_VALUE, true, \
    281                                PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID, \
    282                                op); \
     268                    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     269                            PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID, \
     270                            op); \
    283271                    return 5; \
    284272                } \
    … …  
    303291            char* typeStr;
    304292            PS_TYPE_NAME(typeStr,type);
    305             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageOverlaySection",
    306                        PS_ERR_BAD_PARAMETER_TYPE, true,
    307                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    308                        typeStr);
     293            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     294                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     295                    typeStr);
    309296            return 6;
    310297        }
    … …  
    329316
    330317    if (input == NULL) {
    331         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion",
    332                    PS_ERR_BAD_PARAMETER_NULL, true,
    333                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     318        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     319                PS_ERRORTEXT_psImage_IMAGE_NULL);
    334320        return 0;
    335321    }
    336322
    337323    if (realMax < realMin) {
    338         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion",
    339                    PS_ERR_BAD_PARAMETER_VALUE, true,
    340                    PS_ERRORTEXT_psImageManip_MAXMIN_REAL,
    341                    (double)realMin, (double)realMax);
     324        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     325                PS_ERRORTEXT_psImageManip_MAXMIN_REAL,
     326                (double)realMin, (double)realMax);
    342327        return 0;
    343328    }
    344329    if (imagMax < imagMin) {
    345         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion",
    346                    PS_ERR_BAD_PARAMETER_VALUE, true,
    347                    PS_ERRORTEXT_psImageManip_MAXMIN_IMAG,
    348                    (double)imagMin, (double)imagMax);
     330        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     331                PS_ERRORTEXT_psImageManip_MAXMIN_IMAG,
     332                (double)imagMin, (double)imagMax);
    349333        return 0;
    350334    }
    … …  
    357341        if (realfcn(vmin) < PS_MIN_##type || imagfcn(vmin) < PS_MIN_##type || \
    358342                realfcn(vmin) > PS_MAX_##type || imagfcn(vmin) > PS_MAX_##type ) { \
    359             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion", \
    360                        PS_ERR_BAD_PARAMETER_VALUE, true, \
    361                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    362                        "vmin", creal(vmin), cimag(vmin), \
    363                        PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
     343            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     344                    PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     345                    "vmin", creal(vmin), cimag(vmin), \
     346                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
    364347            break; \
    365348        } \
    366349        if (realfcn(vmax) > PS_MAX_##type || imagfcn(vmax) > PS_MAX_##type || \
    367350                realfcn(vmax) < PS_MIN_##type || imagfcn(vmax) < PS_MIN_##type ) { \
    368             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion", \
    369                        PS_ERR_BAD_PARAMETER_VALUE, true, \
    370                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    371                        "vmax", creal(vmax), cimag(vmax), \
    372                        PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
     351            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     352                    PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     353                    "vmax", creal(vmax), cimag(vmax), \
     354                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
    373355            break; \
    374356        } \
    … …  
    396378            char* typeStr;
    397379            PS_TYPE_NAME(typeStr,input->type.type);
    398             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageClipComplexRegion",
    399                        PS_ERR_BAD_PARAMETER_TYPE, true,
    400                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    401                        typeStr);
     380            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     381                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     382                    typeStr);
    402383        }
    403384    }
    … …  
    424405
    425406    if (in == NULL) {
    426         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    427                    PS_ERR_BAD_PARAMETER_NULL, true,
    428                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     407        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     408                PS_ERRORTEXT_psImage_IMAGE_NULL);
    429409        psFree(out);
    430410        return NULL;
    … …  
    432412
    433413    if (scale < 1) {
    434         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    435                    PS_ERR_BAD_PARAMETER_VALUE, true,
    436                    PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
    437                    scale);
     414        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     415                PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
     416                scale);
    438417        psFree(out);
    439418        return NULL;
    … …  
    441420
    442421    if (stats == NULL) {
    443         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    444                    PS_ERR_BAD_PARAMETER_NULL, true,
    445                    PS_ERRORTEXT_psImage_STAT_NULL);
     422        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     423                PS_ERRORTEXT_psImage_STAT_NULL);
    446424        psFree(out);
    447425        return NULL;
    … …  
    449427
    450428    if (p_psGetStatValue(stats, &statVal) == false) {
    451         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    452                    PS_ERR_BAD_PARAMETER_VALUE, true,
    453                    PS_ERRORTEXT_psImage_BAD_STAT,
    454                    stats->options);
     429        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     430                PS_ERRORTEXT_psImage_BAD_STAT,
     431                stats->options);
    455432        psFree(out);
    456433        return NULL;
    … …  
    463440            char* typeStr;
    464441            PS_TYPE_NAME(typeStr,mask->type.type);
    465             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    466                        PS_ERR_BAD_PARAMETER_TYPE, true,
    467                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    468                        typeStr, PS_TYPE_MASK_NAME);
     442            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     443                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     444                    typeStr, PS_TYPE_MASK_NAME);
    469445            psFree(out);
    470446            psFree(vec);
    … …  
    536512            char* typeStr;
    537513            PS_TYPE_NAME(typeStr,in->type.type);
    538             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRebin",
    539                        PS_ERR_BAD_PARAMETER_TYPE, true,
    540                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    541                        typeStr);
     514            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     515                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     516                    typeStr);
    542517            psFree(out);
    543518            out = NULL;
    … …  
    562537
    563538    if (in == NULL) {
    564         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageResample",
    565                    PS_ERR_BAD_PARAMETER_NULL, true,
    566                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     539        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     540                PS_ERRORTEXT_psImage_IMAGE_NULL);
    567541        psFree(out);
    568542        return NULL;
    … …  
    570544
    571545    if (scale < 1) {
    572         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageResample",
    573                    PS_ERR_BAD_PARAMETER_VALUE, true,
    574                    PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
    575                    scale);
     546        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     547                PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
     548                scale);
    576549        psFree(out);
    577550        return NULL;
    … …  
    579552
    580553    if (mode < PS_INTERPOLATE_FLAT || mode >= PS_INTERPOLATE_NUM_MODES) {
    581         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageResample",
    582                    PS_ERR_BAD_PARAMETER_VALUE, true,
    583                    PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
    584                    mode);
     554        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     555                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     556                mode);
    585557        psFree(out);
    586558        return NULL;
    … …  
    622594            char* typeStr;
    623595            PS_TYPE_NAME(typeStr,in->type.type);
    624             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageResample",
    625                        PS_ERR_BAD_PARAMETER_TYPE, true,
    626                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    627                        typeStr);
     596            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     597                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     598                    typeStr);
    628599            psFree(out);
    629600            out = NULL;
    … …  
    644615
    645616    if (in == NULL) {
    646         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRoll",
    647                    PS_ERR_BAD_PARAMETER_NULL, true,
    648                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     617        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     618                PS_ERRORTEXT_psImage_IMAGE_NULL);
    649619        psFree(out);
    650620        return NULL;
    … …  
    694664{
    695665    if (in == NULL) {
    696         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate",
    697                    PS_ERR_BAD_PARAMETER_NULL, true,
    698                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     666        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     667                PS_ERRORTEXT_psImage_IMAGE_NULL);
    699668        psFree(out);
    700669        return NULL;
    … …  
    741710                char* typeStr;
    742711                PS_TYPE_NAME(typeStr,type);
    743                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate",
    744                            PS_ERR_BAD_PARAMETER_TYPE, true,
    745                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    746                            typeStr);
     712                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     713                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     714                        typeStr);
    747715                psFree(out);
    748716                return NULL;
    … …  
    788756                char* typeStr;
    789757                PS_TYPE_NAME(typeStr,type);
    790                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate",
    791                            PS_ERR_BAD_PARAMETER_TYPE, true,
    792                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    793                            typeStr);
     758                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     759                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     760                        typeStr);
    794761                psFree(out);
    795762                return NULL;
    … …  
    834801                char* typeStr;
    835802                PS_TYPE_NAME(typeStr,type);
    836                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate",
    837                            PS_ERR_BAD_PARAMETER_TYPE, true,
    838                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
    839                            typeStr);
     803                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     804                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     805                        typeStr);
    840806                psFree(out);
    841807                return NULL;
    … …  
    891857                    cimag(unexposedValue) < PS_MIN_##TYPE || \
    892858                    cimag(unexposedValue) > PS_MAX_##TYPE) { \
    893                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate", \
    894                            PS_ERR_BAD_PARAMETER_VALUE, true, \
    895                            PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    896                            "unexposedValue", \
    897                            creal(unexposedValue),cimag(unexposedValue), \
    898                            PS_TYPE_##TYPE##_NAME,  \
    899                            (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     859                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     860                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     861                        "unexposedValue", \
     862                        creal(unexposedValue),cimag(unexposedValue), \
     863                        PS_TYPE_##TYPE##_NAME,  \
     864                        (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
    900865                psFree(out); \
    901866                out = NULL; \
    … …  
    959924                char* typeStr; \
    960925                PS_TYPE_NAME(typeStr,type); \
    961                 psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate", \
    962                            PS_ERR_BAD_PARAMETER_TYPE, true, \
    963                            PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
    964                            typeStr); \
     926                psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
     927                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
     928                        typeStr); \
    965929                psFree(out); \
    966930                out = NULL; \
    … …  
    973937            PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR);
    974938        default:
    975             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate",
    976                        PS_ERR_BAD_PARAMETER_VALUE, true,
    977                        PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
    978                        mode);
     939            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     940                    PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     941                    mode);
    979942            psFree(out);
    980943            out = NULL;
    … …  
    998961
    999962    if (in == NULL) {
    1000         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageShift",
    1001                    PS_ERR_BAD_PARAMETER_NULL, true,
    1002                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     963        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     964                PS_ERRORTEXT_psImage_IMAGE_NULL);
    1003965        psFree(out);
    1004966        return NULL;
    … …  
    1018980            cimag(unexposedValue) < PS_MIN_##TYPE || \
    1019981            cimag(unexposedValue) > PS_MAX_##TYPE) { \
    1020         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageShift", \
    1021                    PS_ERR_BAD_PARAMETER_VALUE, true, \
    1022                    PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
    1023                    "unexposedValue", \
    1024                    creal(unexposedValue),cimag(unexposedValue), \
    1025                    PS_TYPE_##TYPE##_NAME,  \
    1026                    (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
     982        psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
     983                PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     984                "unexposedValue", \
     985                creal(unexposedValue),cimag(unexposedValue), \
     986                PS_TYPE_##TYPE##_NAME,  \
     987                (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
    1027988        psFree(out); \
    1028989        out = NULL; \
    … …  
    10581019            char* typeStr; \
    10591020            PS_TYPE_NAME(typeStr,type); \
    1060             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageRotate", \
    1061                        PS_ERR_BAD_PARAMETER_TYPE, true, \
    1062                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
    1063                        typeStr); \
     1021            psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
     1022                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
     1023                    typeStr); \
    10641024            psFree(out); \
    10651025            out = NULL; \
    … …  
    10731033        PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR);
    10741034    default:
    1075         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageShift",
    1076                    PS_ERR_BAD_PARAMETER_VALUE, true,
    1077                    PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
    1078                    mode);
     1035        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     1036                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     1037                mode);
    10791038        psFree(out);
    10801039        out = NULL;

  • trunk/psLib/src/image/psImageStats.c

    r2265 r2273  
    11/** @file psImageStats.c
    2 *  \brief Routines for calculating statistics on images.
    3 *  @ingroup ImageStats
    4 *
    5 *  This file will hold the prototypes for procedures which calculate
    6 *  statistic on images, histograms on images, and fit/evaluate Chebyshev
    7 *  polynomials to images.
    8 *
    9 *  @author GLG, MHPCC
    10 *
    11 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2004-11-02 03:57:21 $
    13 *
    14 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    15 */
     2 *  \brief Routines for calculating statistics on images.
     3 *  @ingroup ImageStats
     4 *
     5 *  This file will hold the prototypes for procedures which calculate
     6 *  statistic on images, histograms on images, and fit/evaluate Chebyshev
     7 *  polynomials to images.
     8 *
     9 *  @author GLG, MHPCC
     10 *
     11 *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-11-04 01:05:00 $
     13 *
     14 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
     15 */
    1616
    1717#include <stdlib.h>
    … …  
    4646
    4747    if (stats == NULL) {
    48         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageStats",
    49                    PS_ERR_BAD_PARAMETER_NULL, true,
    50                    PS_ERRORTEXT_psImage_STAT_NULL);
     48        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     49                PS_ERRORTEXT_psImage_STAT_NULL);
    5150        return NULL;
    5251    }
    5352
    5453    if (in == NULL) {
    55         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageStats",
    56                    PS_ERR_BAD_PARAMETER_NULL, true,
    57                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     54        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     55                PS_ERRORTEXT_psImage_IMAGE_NULL);
    5856        return NULL;
    5957    }
    6058
    6159    if (stats->options == 0) {
    62         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageStats",
    63                    PS_ERR_BAD_PARAMETER_VALUE, true,
    64                    PS_ERRORTEXT_psImage_NO_STAT_OPTIONS);
     60        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     61                PS_ERRORTEXT_psImage_NO_STAT_OPTIONS);
    6562        return stats;
    6663    }
    … …  
    7673            char* typeStr;
    7774            PS_TYPE_NAME(typeStr,mask->type.type);
    78             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageStats",
    79                        PS_ERR_BAD_PARAMETER_TYPE, true,
    80                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    81                        typeStr, PS_TYPE_MASK_NAME);
     75            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     76                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     77                    typeStr, PS_TYPE_MASK_NAME);
    8278            psFree(junkData);
    8379            return NULL;
    … …  
    125121            char* typeStr;
    126122            PS_TYPE_NAME(typeStr,mask->type.type);
    127             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageHistogram",
    128                        PS_ERR_BAD_PARAMETER_TYPE, true,
    129                        PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
    130                        typeStr, PS_TYPE_MASK_NAME);
     123            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     124                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     125                    typeStr, PS_TYPE_MASK_NAME);
    131126            psFree(out);
    132127            psFree(junkData);
    … …  
    150145
    151146/*****************************************************************************
    152 CalcScaleFactorsEval(n): The Chebyshev polynomials are defined over the
     147calcScaleFactorsEval(n): The Chebyshev polynomials are defined over the
    153148interval [-1.0 : 1.0].  Images typically have sizes of 512x512 or more.  In
    154149order to use Chebyshev polynomials, we must scale the coordinates from
    … …  
    156151output a vector of evenly spaced floating point values between -1.0:1.0.
    157152 *****************************************************************************/
    158 double *CalcScaleFactors(psS32 n)
    159 {
    160     PS_INT_CHEC_NON_NEGATIVE(n, NULL);
     153double* calcScaleFactors(psS32 n)
     154{
     155    PS_INT_CHECK_NON_NEGATIVE(n, NULL);
    161156    psS32 i = 0;
    162157    double tmp = 0.0;
    … …  
    172167}
    173168
    174 psVector *VecCalcScaleFactors(psVector *scalingFactors, psS32 n)
     169psVector *VeccalcScaleFactors(psVector *scalingFactors, psS32 n)
    175170{
    176171    PS_VECTOR_CHECK_NULL(scalingFactors, NULL);
    177172    PS_VECTOR_CHECK_TYPE(scalingFactors, PS_TYPE_F64, NULL);
    178     PS_INT_CHEC_NON_NEGATIVE(n, NULL);
     173    PS_INT_CHECK_NON_NEGATIVE(n, NULL);
    179174    psS32 i = 0;
    180175    double tmp = 0.0;
    … …  
    243238            (input->type.type != PS_TYPE_F32) &&
    244239            (input->type.type != PS_TYPE_F64)) {
    245         psError(__func__, "Unalowwable image type.\n");
     240        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     241                "Unallowable image type.\n");
    246242    }
    247243    PS_POLY_CHECK_NULL(coeffs, NULL);
    … …  
    259255    // Check for null inputs
    260256    if (input == NULL) {
    261         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFitPolynomial",
    262                    PS_ERR_BAD_PARAMETER_NULL, true,
    263                    PS_ERRORTEXT_psImage_IMAGE_NULL);
     257        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     258                PS_ERRORTEXT_psImage_IMAGE_NULL);
    264259        return NULL;
    265260    }
    266261
    267262    if (coeffs == NULL) {
    268         psErrorMsg(PS_ERRORNAME_DOMAIN "psImageFitPolynomial",
    269                    PS_ERR_BAD_PARAMETER_NULL, true,
    270                    PS_ERRORTEXT_psImage_COEFF_NULL);
     263        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     264                PS_ERRORTEXT_psImage_COEFF_NULL);
    271265        return NULL;
    272266    }
    … …  
    283277    // We scale the pixel positions to values
    284278    // between -1.0 and 1.0
    285     rScalingFactors = CalcScaleFactors(input->numRows);
    286     cScalingFactors = CalcScaleFactors(input->numCols);
     279    rScalingFactors = calcScaleFactors(input->numRows);
     280    cScalingFactors = calcScaleFactors(input->numCols);
    287281
    288282    // Determine how many Chebyshev polynomials
    … …  
    363357            (input->type.type != PS_TYPE_F32) &&
    364358            (input->type.type != PS_TYPE_F64)) {
    365         psError(__func__, "Unalowwable image type.\n");
     359        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     360                "Unallowable image type.\n");
    366361    }
    367362    PS_POLY_CHECK_NULL(coeffs, NULL);
    … …  
    376371    double *cScalingFactors = NULL;
    377372    double *rScalingFactors = NULL;
    378     double polySum = 0.0;
    379 
     373    float polySum = 0.0;
     374
     375    // Check for null inputs
     376    if (input == NULL) {
     377        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     378                PS_ERRORTEXT_psImage_IMAGE_NULL);
     379        return NULL;
     380    }
     381
     382    if (coeffs == NULL) {
     383        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     384                PS_ERRORTEXT_psImage_COEFF_NULL);
     385        return NULL;
     386    }
    380387
    381388    // We scale the pixel positions to values between -1.0 and 1.0
    382389    // Use static data structures here.
    383     rScalingFactors = CalcScaleFactors(input->numRows);
    384     cScalingFactors = CalcScaleFactors(input->numCols);
     390    rScalingFactors = calcScaleFactors(input->numRows);
     391    cScalingFactors = calcScaleFactors(input->numCols);
    385392
    386393    // Determine how many Chebyshev polynomials
Note: See TracChangeset for help on using the changeset viewer.