IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 7, 2005, 11:35:50 AM (21 years ago)
Author:
gusciora
Message:

Split of psFunctions.c into psSpline.c and psPolynomial.c.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/math/psMinimize.c

    r4944 r4958  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.133 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-09-02 21:32:06 $
     11 *  @version $Revision: 1.134 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-09-07 21:35:50 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929#include "psImageStructManip.h"
    3030#include "psBinaryOp.h"
     31#include "psLogMsg.h"
    3132/*****************************************************************************/
    3233/* DEFINE STATEMENTS                                                         */
    … …  
    112113
    113114/******************************************************************************
    114 p_psBuildSums1D(x, polyOrder, sums): this routine calculates the powers of
    115 input parameter "x" between 0 and input parameter polyOrder.  The result is
    116 returned as a psVector sums.
     115buildSums1D(x, polyOrder, sums): this routine calculates the powers of input
     116parameter "x" between 0 and input parameter polyOrder.  The result is returned
     117as a psVector sums.
    117118 
    118119XXX: Use a static vector.
     120 
     121XXX: should the argument be polyOrder or numTerms?
    119122 *****************************************************************************/
    120123static void buildSums1D(psF64 x,
    … …  
    124127    psS32 i = 0;
    125128    psF64 xSum = 0.0;
     129    psS32 numTerms = polyOrder + 1;
    126130
    127131    if (sums == NULL) {
    128         sums = psVectorAlloc(polyOrder, PS_TYPE_F64);
    129     }
    130     if (polyOrder > sums->n) {
    131         sums = psVectorRealloc(sums, polyOrder);
     132        sums = psVectorAlloc(numTerms, PS_TYPE_F64);
     133    } else if (numTerms > sums->n) {
     134        sums = psVectorRealloc(sums, numTerms);
    132135    }
    133136
    134137    xSum = 1.0;
    135     for (i = 0; i <= polyOrder; i++) {
     138    for (i = 0; i < numTerms; i++) {
    136139        sums->data.F64[i] = xSum;
    137140        xSum *= x;
    … …  
    708711those coords.
    709712 
    710 // XXX EAM this is my re-implementation of MinLM
     713XXX EAM this is my re-implementation of MinLM
    711714 
    712715XXX: This must work for both F32 and F64.  F32 is currently implemented.
    … …  
    13061309 
    13071310XXX: type F32 is done via vector conversion only.
     1311 
     1312XXX: Get rid of this.  Use new argument list.
    13081313 *****************************************************************************/
    13091314psPolynomial1D* psVectorFitPolynomial1D(psPolynomial1D* poly,
    … …  
    21432148
    21442149/******************************************************************************
     2150 ******************************************************************************
     2151 ******************************************************************************
     2152 ******************************************************************************
    21452153EAM Code:
     2154 ******************************************************************************
     2155 ******************************************************************************
     2156 ******************************************************************************
    21462157 *****************************************************************************/
    21472158
    2148 // XXX EAM : my alternate EAMBuildSums1D
    21492159static psVector *EAMBuildSums1D(
    21502160    psVector* sums,
    … …  
    21552165    psF64 xSum = 0.0;
    21562166
     2167    //
     2168    // XXX: Why do we multiply by 2 here?  Better to do it outside and have the
     2169    // definition of this function remain sensible.
     2170    //
    21572171    nSum = 2*nTerm;
    21582172    if (sums == NULL) {
    21592173        sums = psVectorAlloc(nSum, PS_TYPE_F64);
    2160     }
    2161     if (nSum > sums->n) {
     2174    } else if (nSum > sums->n) {
    21622175        sums = psVectorRealloc(sums, nSum);
    21632176    }
    … …  
    21772190    const psVector *x,
    21782191    const psVector *y,
    2179     const psVector *yErr
    2180 )
     2192    const psVector *yErr)
    21812193{
    21822194    // I think this is 1 dimension down
    … …  
    22772289    const psPolynomial2D *myPoly,
    22782290    const psVector *x,
    2279     const psVector *y
    2280 )
     2291    const psVector *y)
    22812292{
    22822293    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    … …  
    23122323    psF64 y,
    23132324    psS32 nXterm,
    2314     psS32 nYterm
    2315 )
     2325    psS32 nYterm)
    23162326{
    23172327    psS32 nXsum = 0;
    … …  
    23492359    const psVector* y,
    23502360    const psVector* z,
    2351     const psVector* zErr
    2352 )
     2361    const psVector* zErr)
    23532362{
    23542363    // I think this is 1 dimension down
    … …  
    24392448    const psVector* y,
    24402449    const psVector* z,
    2441     const psVector* dz
    2442 )
     2450    const psVector* dz)
    24432451{
    24442452    psVector *X;
    … …  
    24872495
    24882496// XXX EAM : be careful here with F32 vs F64 vectors
     2497/*
     2498 Basically, you repetitively fit a polynomial to a set of data points,
     2499 reject the points that did not fit well, then refit the polynomial.
     2500 
     2501 Basically, simply fit the polynomial to the data.  They compare the
     2502 fit (by evaluating the x data with that polynomial and subtracting
     2503 from the original f data).  That's the residual.  Loop through all
     2504 data and if the ((residual - mean) > 3*stDev), mask that data point,
     2505 and fit the polynomial again.  Do this 3 times.
     2506*/
     2507
    24892508psPolynomial2D* RobustFit2D(psPolynomial2D* poly,
    24902509                            psVector* mask,
    … …  
    25312550}
    25322551
    2533 
     2552/******************************************************************************
     2553 ******************************************************************************
     2554 ******************************************************************************
     2555 ******************************************************************************
     2556NEW Code:
     2557 ******************************************************************************
     2558 ******************************************************************************
     2559 ******************************************************************************
     2560 *****************************************************************************/
     2561
     2562#define PS_VECTOR_GEN_INDEX_F32(VEC, SIZE) \
     2563VEC = psVectorAlloc(SIZE, PS_TYPE_F32); \
     2564for (psS32 i = 0 ; i < SIZE ; i++) { \
     2565    VEC->data.F32[i] = (psF32) i; \
     2566} \
     2567
     2568psPolynomial1D *psVectorFitPolynomial1D_NEW(
     2569    psPolynomial1D *poly,
     2570    const psVector *mask,
     2571    psMaskType maskValue,
     2572    const psVector *f,
     2573    const psVector *fErr,
     2574    const psVector *x)
     2575{
     2576    // Internal pointers for possibly NULL vectors.
     2577    psVector *x32 = NULL;
     2578    psVector *fErr32 = NULL;
     2579
     2580    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2581    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2582    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2583    if (mask != NULL) {
     2584        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2585        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2586    }
     2587    if (x != NULL) {
     2588        PS_ASSERT_VECTORS_SIZE_EQUAL(f, x, NULL);
     2589        PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2590    } else {
     2591        PS_VECTOR_GEN_INDEX_F32(x32, f->n);
     2592    }
     2593
     2594    if (fErr != NULL) {
     2595        PS_ASSERT_VECTORS_SIZE_EQUAL(f, fErr, NULL);
     2596        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2597    } else {
     2598        fErr = psVectorAlloc(f->n, PS_TYPE_F32);
     2599        PS_VECTOR_SET_F32(fErr, 1.0);
     2600    }
     2601
     2602    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2603    if (poly->type == PS_POLYNOMIAL_ORD) {
     2604        // XXX: Call EAM code
     2605    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     2606        // XXX: Call my code
     2607    } else {
     2608        printf("XXX: ERROR: incorrect polynomial type.\n");
     2609    }
     2610
     2611    // Free psVectors that were created for NULL arguments.
     2612    if (x == NULL) {
     2613        psFree(x32);
     2614    }
     2615    if (fErr == NULL) {
     2616        psFree(fErr32);
     2617    }
     2618
     2619    return(NULL);
     2620}
     2621
     2622
     2623psPolynomial2D *psVectorFitPolynomial2D_NEW(
     2624    psPolynomial1D *poly,
     2625    const psVector *mask,
     2626    psMaskType maskValue,
     2627    const psVector *f,
     2628    const psVector *fErr,
     2629    const psVector *x,
     2630    const psVector *y)
     2631{
     2632    // Internal pointers for possibly NULL vectors.
     2633    psVector *fErr32 = NULL;
     2634
     2635    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2636    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2637    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2638    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2639    if (mask != NULL) {
     2640        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2641        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2642    }
     2643    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2644    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2645    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2646    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2647    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2648    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2649    if (fErr != NULL) {
     2650        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2651        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2652    } else {
     2653        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2654        PS_VECTOR_SET_F32(fErr32, 1.0);
     2655    }
     2656
     2657    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2658    if (poly->type == PS_POLYNOMIAL_ORD) {
     2659        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 2-D polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2660    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     2661        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 2-D Chebyshev polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2662    } else {
     2663        printf("XXX: ERROR: incorrect polynomial type.\n");
     2664    }
     2665    if (fErr == NULL) {
     2666        psFree(fErr32);
     2667    }
     2668    return(NULL);
     2669}
     2670
     2671psPolynomial3D *psVectorFitPolynomial3D_NEW(
     2672    psPolynomial1D *poly,
     2673    const psVector *mask,
     2674    psMaskType maskValue,
     2675    const psVector *f,
     2676    const psVector *fErr,
     2677    const psVector *x,
     2678    const psVector *y,
     2679    const psVector *z)
     2680{
     2681    // Internal pointers for possibly NULL vectors.
     2682    psVector *fErr32 = NULL;
     2683
     2684    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2685    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2686    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2687    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2688    if (mask != NULL) {
     2689        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2690        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2691    }
     2692    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2693    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2694    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2695    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2696    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2697    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2698    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     2699    PS_ASSERT_VECTORS_SIZE_EQUAL(f, z, NULL);
     2700    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
     2701    if (fErr != NULL) {
     2702        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2703        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2704    } else {
     2705        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2706        PS_VECTOR_SET_F32(fErr32, 1.0);
     2707    }
     2708
     2709    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2710    if (poly->type == PS_POLYNOMIAL_ORD) {
     2711        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 3-D polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2712    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     2713        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 3-D Chebyshev polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2714    } else {
     2715        printf("XXX: ERROR: incorrect polynomial type.\n");
     2716    }
     2717    if (fErr == NULL) {
     2718        psFree(fErr32);
     2719    }
     2720    return(NULL);
     2721}
     2722
     2723psPolynomial4D *psVectorFitPolynomial4D_NEW(
     2724    psPolynomial1D *poly,
     2725    const psVector *mask,
     2726    psMaskType maskValue,
     2727    const psVector *f,
     2728    const psVector *fErr,
     2729    const psVector *x,
     2730    const psVector *y,
     2731    const psVector *z,
     2732    const psVector *t)
     2733{
     2734    // Internal pointers for possibly NULL vectors.
     2735    psVector *fErr32 = NULL;
     2736
     2737    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2738    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2739    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2740    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2741    if (mask != NULL) {
     2742        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2743        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2744    }
     2745    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2746    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2747    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2748    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2749    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2750    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2751    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     2752    PS_ASSERT_VECTORS_SIZE_EQUAL(f, z, NULL);
     2753    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
     2754    PS_ASSERT_VECTOR_NON_NULL(t, NULL);
     2755    PS_ASSERT_VECTORS_SIZE_EQUAL(f, t, NULL);
     2756    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F32, NULL);
     2757    if (fErr != NULL) {
     2758        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2759        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2760    } else {
     2761        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2762        PS_VECTOR_SET_F32(fErr32, 1.0);
     2763    }
     2764
     2765    if (poly->type == PS_POLYNOMIAL_ORD) {
     2766        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 4-D polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2767    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
     2768        psLogMsg(__func__, PS_LOG_WARN, "WARNING: 4-D Chebyshev polynomial vector fitting has not been implemented.  Returning NULL.\n");
     2769    } else {
     2770        printf("XXX: ERROR: incorrect polynomial type.\n");
     2771    }
     2772    if (fErr == NULL) {
     2773        psFree(fErr32);
     2774    }
     2775    return(NULL);
     2776}
     2777
     2778
     2779psPolynomial1D *psVectorClipFitPolynomial1D_NEW(
     2780    psPolynomial1D *poly,
     2781    psStats *stats,
     2782    const psVector *mask,
     2783    psMaskType maskValue,
     2784    const psVector *f,
     2785    const psVector *fErr,
     2786    const psVector *x)
     2787{
     2788    // Internal pointers for possibly NULL vectors.
     2789    psVector *x32 = NULL;
     2790    psVector *fErr32 = NULL;
     2791
     2792    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2793    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2794    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2795    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2796    if (mask != NULL) {
     2797        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2798        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2799    }
     2800    if (x != NULL) {
     2801        PS_ASSERT_VECTORS_SIZE_EQUAL(f, x, NULL);
     2802        PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2803    }
     2804    if (fErr != NULL) {
     2805        PS_ASSERT_VECTORS_SIZE_EQUAL(f, fErr, NULL);
     2806        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2807    } else {
     2808        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2809        PS_VECTOR_SET_F32(fErr32, 1.0);
     2810    }
     2811
     2812    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2813    // Free psVectors that were created for NULL arguments.
     2814    if (x == NULL) {
     2815        psFree(x32);
     2816    }
     2817    if (fErr == NULL) {
     2818        psFree(fErr32);
     2819    }
     2820    return(NULL);
     2821}
     2822
     2823psPolynomial2D *psVectorClipFitPolynomial2D_NEW(
     2824    psPolynomial1D *poly,
     2825    psStats *stats,
     2826    const psVector *mask,
     2827    psMaskType maskValue,
     2828    const psVector *f,
     2829    const psVector *fErr,
     2830    const psVector *x,
     2831    const psVector *y)
     2832{
     2833    // Internal pointers for possibly NULL vectors.
     2834    psVector *fErr32 = NULL;
     2835
     2836    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2837    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2838    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2839    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2840    if (mask != NULL) {
     2841        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2842        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2843    }
     2844    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2845    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2846    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2847    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2848    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2849    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2850    if (fErr != NULL) {
     2851        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2852        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2853    } else {
     2854        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2855        PS_VECTOR_SET_F32(fErr32, 1.0);
     2856    }
     2857
     2858    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2859    if (fErr == NULL) {
     2860        psFree(fErr32);
     2861    }
     2862    return(NULL);
     2863}
     2864
     2865psPolynomial3D *psVectorClipFitPolynomial3D_NEW(
     2866    psPolynomial1D *poly,
     2867    psStats *stats,
     2868    const psVector *mask,
     2869    psMaskType maskValue,
     2870    const psVector *f,
     2871    const psVector *fErr,
     2872    const psVector *x,
     2873    const psVector *y,
     2874    const psVector *z)
     2875{
     2876    // Internal pointers for possibly NULL vectors.
     2877    psVector *fErr32 = NULL;
     2878
     2879    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2880    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2881    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2882    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2883    if (mask != NULL) {
     2884        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2885        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2886    }
     2887    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2888    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2889    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2890    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2891    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2892    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2893    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     2894    PS_ASSERT_VECTORS_SIZE_EQUAL(f, z, NULL);
     2895    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
     2896    if (fErr != NULL) {
     2897        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2898        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2899    } else {
     2900        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2901        PS_VECTOR_SET_F32(fErr32, 1.0);
     2902    }
     2903
     2904    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2905    if (fErr == NULL) {
     2906        psFree(fErr32);
     2907    }
     2908    return(NULL);
     2909}
     2910
     2911psPolynomial4D *psVectorClipFitPolynomial4D_NEW(
     2912    psPolynomial1D *poly,
     2913    psStats *stats,
     2914    const psVector *mask,
     2915    psMaskType maskValue,
     2916    const psVector *f,
     2917    const psVector *fErr,
     2918    const psVector *x,
     2919    const psVector *y,
     2920    const psVector *z,
     2921    const psVector *t)
     2922{
     2923    // Internal pointers for possibly NULL vectors.
     2924    psVector *fErr32 = NULL;
     2925
     2926    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     2927    PS_ASSERT_POLY_TYPE(poly, PS_POLYNOMIAL_ORD, NULL);
     2928    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     2929    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F32, NULL);
     2930    if (mask != NULL) {
     2931        PS_ASSERT_VECTORS_SIZE_EQUAL(f, mask, NULL);
     2932        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
     2933    }
     2934    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2935    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2936    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     2937    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     2938    PS_ASSERT_VECTORS_SIZE_EQUAL(f, y, NULL);
     2939    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     2940    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     2941    PS_ASSERT_VECTORS_SIZE_EQUAL(f, z, NULL);
     2942    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
     2943    PS_ASSERT_VECTOR_NON_NULL(t, NULL);
     2944    PS_ASSERT_VECTORS_SIZE_EQUAL(f, t, NULL);
     2945    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F32, NULL);
     2946    if (fErr != NULL) {
     2947        PS_ASSERT_VECTORS_SIZE_EQUAL(fErr, mask, NULL);
     2948        PS_ASSERT_VECTOR_TYPE(fErr, PS_TYPE_F32, NULL);
     2949    } else {
     2950        fErr32 = psVectorAlloc(f->n, PS_TYPE_F32);
     2951        PS_VECTOR_SET_F32(fErr32, 1.0);
     2952    }
     2953
     2954    psLogMsg(__func__, PS_LOG_WARN, "WARNING: This function has not been implemented.  Returning NULL.\n");
     2955    if (fErr == NULL) {
     2956        psFree(fErr32);
     2957    }
     2958    return(NULL);
     2959}
     2960
     2961
Note: See TracChangeset for help on using the changeset viewer.