IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4362


Ignore:
Timestamp:
Jun 22, 2005, 4:10:51 PM (21 years ago)
Author:
Paul Price
Message:

psMask changed to psMaskType, reverting unsigned long for psArray size back to long

Location:
trunk/doc/pslib
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/pslib/ChangeLogSDRS.tex

    r4357 r4362  
    1 %%% $Id: ChangeLogSDRS.tex,v 1.149 2005-06-23 01:10:24 price Exp $
     1%%% $Id: ChangeLogSDRS.tex,v 1.150 2005-06-23 02:10:51 price Exp $
    22
    33\subsection{Changes from version 00 to version 01}
    … …  
    735735\item Removed \code{psLookupTableStatusType} (see bugs 304, 454).
    736736\item Added \code{psArrayElementsFree} (already implemented).
    737 \item Sizes in \code{psArray} are \code{unsigned long}.
     737\item \code{psMask} changed to \code{psMaskType} (more clear).
    738738\item Use the \code{region} in \code{psImageTransform} to set the size of the output image (bug 453).
    739739\end{itemize}

  • trunk/doc/pslib/psLibSDRS.tex

    r4357 r4362  
    1 %%% $Id: psLibSDRS.tex,v 1.292 2005-06-23 01:10:24 price Exp $
     1%%% $Id: psLibSDRS.tex,v 1.293 2005-06-23 02:10:51 price Exp $
    22\documentclass[panstarrs,spec]{panstarrs}
    33
    … …  
    16111611\begin{datatype}
    16121612typedef struct {
    1613     const unsigned long n;              ///< size of array
    1614     const unsigned long nalloc;         ///< allocated data block
     1613    const long n;                       ///< size of array
     1614    const long nalloc;                  ///< allocated data block
    16151615    psPtr *data;                        ///< pointer to data block
    16161616    void *lock;                         ///< Optional lock for thread safety
    … …  
    16251625%
    16261626\begin{prototype}
    1627 psArray *psArrayAlloc(unsigned long nalloc);
    1628 psArray *psArrayRealloc(psArray *array, unsigned long nalloc);
     1627psArray *psArrayAlloc(long nalloc);
     1628psArray *psArrayRealloc(psArray *array, long nalloc);
    16291629\end{prototype}
    16301630%
    … …  
    39153915
    39163916\begin{datatype}
    3917 typedef psU8 psMask;
     3917typedef psU8 psMaskType;
    39183918\end{datatype}
    39193919
    … …  
    39523952                       const psVector *errors,
    39533953                       const psVector *mask,
    3954                        psMask maskVal
     3954                       psMaskType maskVal
    39553955                       );
    39563956\end{prototype}
    … …  
    39813981clipped statistics are modified according to the ADD; the robust
    39823982median and quartiles are modified as specified in the ADD.  The mask
    3983 must be of type \code{psMask}.
     3983must be of type \code{psMaskType}.
    39843984
    39853985The \code{psStats} structure is defined with entries for each of the
    … …  
    40964096                               const psVector *errors,
    40974097                               const psVector *mask,
    4098                                psMask maskVal);
     4098                               psMaskType maskVal);
    40994099\end{prototype}
    41004100The \code{values} vector may be of types \code{psU8, psU16, psF32,
    … …  
    44084408identical.
    44094409
    4410 \code{paramMask} must be of type \code{psMask}, while \code{params}
     4410\code{paramMask} must be of type \code{psMaskType}, while \code{params}
    44114411must be of type \code{psF32}.  The \code{func} function must be valid
    44124412only for types \code{psF32}, \code{psF64}.
    … …  
    45184518psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *poly,
    45194519                                        const psVector *mask,
    4520                                         psMask          maskValue
     4520                                        psMaskType      maskValue
    45214521                                        const psVector *f,
    45224522                                        const psVector *fErr
    45234523                                        const psVector *x);
    4524 psPolynomial2D *psVectorFitPolynomial2D(psPolynomial1D *poly,
     4524psPolynomial2D *psVectorFitPolynomial2D(psPolynomial2D *poly,
    45254525                                        const psVector *mask,
    4526                                         psMask          maskValue
     4526                                        psMaskType      maskValue
    45274527                                        const psVector *f,
    45284528                                        const psVector *fErr
    45294529                                        const psVector *x,
    45304530                                        const psVector *y);
    4531 psPolynomial3D *psVectorFitPolynomial3D(psPolynomial1D *poly,
     4531psPolynomial3D *psVectorFitPolynomial3D(psPolynomial3D *poly,
    45324532                                        const psVector *mask,
    4533                                         psMask          maskValue
     4533                                        psMaskType      maskValue
    45344534                                        const psVector *f,
    45354535                                        const psVector *fErr
    … …  
    45374537                                        const psVector *y,
    45384538                                        const psVector *z);
    4539 psPolynomial4D *psVectorFitPolynomial4D(psPolynomial1D *poly,
     4539psPolynomial4D *psVectorFitPolynomial4D(psPolynomial4D *poly,
    45404540                                        const psVector *mask,
    4541                                         psMask          maskValue
     4541                                        psMaskType      maskValue
    45424542                                        const psVector *f,
    45434543                                        const psVector *fErr
    … …  
    45654565                                        psStats            *stats,
    45664566                                        const psVector     *mask,
    4567                                         psMask              maskValue
     4567                                        psMaskType          maskValue
    45684568                                        const psVector     *f,
    45694569                                        const psVector     *fErr
    45704570                                        const psVector     *x);
    4571 psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial1D *poly,
     4571psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial2D *poly,
    45724572                                        psStats            *stats,
    45734573                                        const psVector     *mask,
    4574                                         psMask              maskValue
     4574                                        psMaskType          maskValue
    45754575                                        const psVector     *f,
    45764576                                        const psVector     *fErr
    45774577                                        const psVector     *x,
    45784578                                        const psVector     *y);
    4579 psPolynomial3D *psVectorClipFitPolynomial3D(psPolynomial1D *poly,
     4579psPolynomial3D *psVectorClipFitPolynomial3D(psPolynomial3D *poly,
    45804580                                        psStats            *stats,
    45814581                                        const psVector     *mask,
    4582                                         psMask              maskValue
     4582                                        psMaskType          maskValue
    45834583                                        const psVector     *f,
    45844584                                        const psVector     *fErr
    … …  
    45864586                                        const psVector     *y,
    45874587                                        const psVector     *z);
    4588 psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial1D *poly,
     4588psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial4D *poly,
    45894589                                        psStats            *stats,
    45904590                                        const psVector     *mask,
    4591                                         psMask              maskValue
     4591                                        psMaskType          maskValue
    45924592                                        const psVector     *f,
    45934593                                        const psVector     *fErr
    … …  
    46964696                       const psImage *input,
    46974697                       const psImage *mask,
    4698                        psMask maskVal,
     4698                       psMaskType maskVal,
    46994699                       psRegion region,
    47004700                       psImageCutDirection direction,
    … …  
    47314731                     const psImage *input,
    47324732                     const psImage *mask,
    4733                      psMask maskVal,
     4733                     psMaskType maskVal,
    47344734                     psRegion region,
    47354735                     unsigned int nSamples,
    … …  
    47514751                           const psImage *input,
    47524752                           const psImage *mask,
    4753                            psMask maskVal,
     4753                           psMaskType maskVal,
    47544754                           float x,
    47554755                           float y,
    … …  
    48024802psImage *psImageRebin(psImage *out, const psImage *in,
    48034803                      const psImage *mask,
    4804                       psMask maskVal,
     4804                      psMaskType maskVal,
    48054805                      int scale, const psStats *stats);
    48064806\end{prototype}
    … …  
    48764876                          const psImage *input,
    48774877                          const psImage *inputMask,
    4878                           psMask inputMaskVal,
     4878                          psMaskType inputMaskVal,
    48794879                          const psPlaneTransform *outToIn,
    48804880                          psRegion region,
    … …  
    48914891If the \code{inputMask} is non-\code{NULL}, those pixels in the
    48924892\code{inputMask} matching \code{inputMaskVal} are to be ignored in the
    4893 transformation.  The \code{inputMask} must be of type \code{psMask}, and
     4893transformation.  The \code{inputMask} must be of type \code{psMaskType}, and
    48944894of the same size as the \code{input}, otherwise the function shall
    48954895generate an error and return \code{NULL}.  The transformation
    … …  
    49174917                      const psImage *in,
    49184918                      const psImage *mask,
    4919                       psMask maskVal);
     4919                      psMaskType maskVal);
    49204920\end{prototype}
    49214921Determine statistics for image (or subimage).  The statistics to be
    … …  
    49304930                              const psImage *in,
    49314931                              const psImage *mask,
    4932                               psMask maskVal);
     4932                              psMaskType maskVal);
    49334933\end{prototype}
    49344934Construct a histogram from an image (or subimage).  The histogram to
    … …  
    49584958\begin{prototype}
    49594959complex double psImagePixelInterpolate(const psImage *input, float x, float y,
    4960                               const psImage *mask, psMask maskVal,
     4960                              const psImage *mask, psMaskType maskVal,
    49614961                              complex double unexposedValue, psImageInterpolateMode mode);
    49624962\end{prototype}
    … …  
    50565056image set to the \code{growValue}.  The function must be defined for
    50575057the following types: \code{psU8}, \code{psU16}.  Note that
    5058 \code{maskVal} and \code{growVal} are not of type \code{psMask}, but
     5058\code{maskVal} and \code{growVal} are not of type \code{psMaskType}, but
    50595059\code{psU16} so that they match the maximum required type for the
    50605060\code{in} image.
    50615061
    50625062\begin{prototype}
    5063 psImage *psPixelsToMask(psImage *out, const psPixels *pixels, psRegion region, psMask maskVal);
    5064 psPixels *psPixelsFromMask(psPixels *out, const psImage *mask, psMask maskVal);
    5065 \end{prototype}
    5066 
    5067 \code{psPixelsToMask} shall return an image of type \code{psMask} with
     5063psImage *psPixelsToMask(psImage *out, const psPixels *pixels, psRegion region, psMaskType maskVal);
     5064psPixels *psPixelsFromMask(psPixels *out, const psImage *mask, psMaskType maskVal);
     5065\end{prototype}
     5066
     5067\code{psPixelsToMask} shall return an image of type \code{psMaskType} with
    50685068the \code{pixels} lying within the specified \code{region} set to the
    50695069\code{maskVal}.  The \code{out} image shall be modified if supplied,
    … …  
    50835083
    50845084\begin{prototype}
    5085 void psImageMaskRegion(psImage *image, psRegion region, const char *op, psMask maskValue);
    5086 void psImageKeepRegion(psImage *image, psRegion region, const char *op, psMask maskValue);
     5085void psImageMaskRegion(psImage *image, psRegion region, const char *op, psMaskType maskValue);
     5086void psImageKeepRegion(psImage *image, psRegion region, const char *op, psMaskType maskValue);
    50875087\end{prototype}
    50885088
    … …  
    50995099\begin{prototype}
    51005100void psImageMaskCircle(psImage *image, double x, double y, double radius, const char *op,
    5101                        psMask maskValue);
     5101                       psMaskType maskValue);
    51025102void psImageKeepCircle(psImage *image, double x, double y, double radius, const char *op,
    5103                        psMask maskValue);
     5103                       psMaskType maskValue);
    51045104\end{prototype}
    51055105
Note: See TracChangeset for help on using the changeset viewer.