Changeset 42492 for branches/eam_branches/ipp-20230313/psLib/src/math/psPolynomial.c

Timestamp:

Aug 15, 2023, 4:56:54 AM (3 years ago)

Author:

eugene

Message:

adding psPolynomial1DCopy, psPolynomial1DRecycle; working on the polynomial IRLS fitting

File:

• branches/eam_branches/ipp-20230313/psLib/src/math/psPolynomial.c (modified) (2 diffs)

branches/eam_branches/ipp-20230313/psLib/src/math/psPolynomial.c

@@ -806 +806 @@
 }
 
-// XXX add 1D, 3D, 4D versions
-bool psPolynomial2DRecycle(psPolynomial2D *poly,
-                           psPolynomialType type,
-                           unsigned int nX,
-                           unsigned int nY)
-{
-    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
-
-    bool match = true;
-    match &= (poly->type == type);
-    match &= (poly->nX == type);
-    match &= (poly->nY == type);
-
-    if (!match) {
-        for (int i = 0; i < poly->nX + 1; i++) {
-            psFree (poly->coeff[i]);
-            psFree (poly->coeffErr[i]);
-            psFree (poly->coeffMask[i]);
-        }
-        psFree (poly->coeff);
-        psFree (poly->coeffErr);
-        psFree (poly->coeffMask);
-
-        poly->type = type;
-        poly->nX = nX;
-        poly->nY = nY;
-
-        poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
-        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
-        poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
-        for (int i = 0; i < (1 + nX); i++) {
-            poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
-            poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
-            poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
-        }
-    }
-    for (int i = 0; i < (1 + nX); i++) {
-        for (int j = 0; j < (1 + nY); j++) {
-            poly->coeff[i][j] = 0.0;
-            poly->coeffErr[i][j] = 0.0;
-            poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
-        }
-    }
-    return(true);
-}
-
-// XXX add 1D, 3D, 4D versions
-psPolynomial2D *psPolynomial2DCopy(psPolynomial2D *out,
-                                   psPolynomial2D *poly)
-{
-    if (out == NULL) {
-        out = psPolynomial2DAlloc (poly->type, poly->nX, poly->nY);
-    } else {
-        psPolynomial2DRecycle (out, poly->type, poly->nX, poly->nY);
-    }
-
-    for (int i = 0; i < (1 + poly->nX); i++) {
-        for (int j = 0; j < (1 + poly->nY); j++) {
-            out->coeff[i][j] = poly->coeff[i][j];
-            out->coeffErr[i][j] = poly->coeffErr[i][j];
-            out->coeffMask[i][j] = poly->coeffMask[i][j];
-        }
-    }
-    return(out);
-}
-
 psPolynomial3D* psPolynomial3DAlloc(
     psPolynomialType type,
@@ -1002 +935 @@
 }
 
+// XXX add 3D, 4D versions
+bool psPolynomial1DRecycle(psPolynomial1D *poly,
+                           psPolynomialType type,
+                           unsigned int nX)
+{
+    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
+
+    bool match = true;
+    match &= (poly->type == type);
+    match &= (poly->nX == type);
+
+    if (!match) {
+        psFree (poly->coeff);
+        psFree (poly->coeffErr);
+        psFree (poly->coeffMask);
+
+        poly->type = type;
+        poly->nX = nX;
+
+        poly->coeff = psAlloc((1 + nX) * sizeof(psF64));
+        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64));
+        poly->coeffMask = (psMaskType *)psAlloc((1 + nX) * sizeof(psMaskType));
+    }
+    for (int i = 0; i < (1 + nX); i++) {
+        poly->coeff[i] = 0.0;
+        poly->coeffErr[i] = 0.0;
+        poly->coeffMask[i] = PS_POLY_MASK_NONE;
+    }
+    return(true);
+}
+
+bool psPolynomial2DRecycle(psPolynomial2D *poly,
+                           psPolynomialType type,
+                           unsigned int nX,
+                           unsigned int nY)
+{
+    PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(nY, NULL);
+
+    bool match = true;
+    match &= (poly->type == type);
+    match &= (poly->nX == type);
+    match &= (poly->nY == type);
+
+    if (!match) {
+        for (int i = 0; i < poly->nX + 1; i++) {
+            psFree (poly->coeff[i]);
+            psFree (poly->coeffErr[i]);
+            psFree (poly->coeffMask[i]);
+        }
+        psFree (poly->coeff);
+        psFree (poly->coeffErr);
+        psFree (poly->coeffMask);
+
+        poly->type = type;
+        poly->nX = nX;
+        poly->nY = nY;
+
+        poly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
+        poly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
+        poly->coeffMask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
+        for (int i = 0; i < (1 + nX); i++) {
+            poly->coeff[i] = psAlloc((1 + nY) * sizeof(psF64));
+            poly->coeffErr[i] = psAlloc((1 + nY) * sizeof(psF64));
+            poly->coeffMask[i] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
+        }
+    }
+    for (int i = 0; i < (1 + nX); i++) {
+        for (int j = 0; j < (1 + nY); j++) {
+            poly->coeff[i][j] = 0.0;
+            poly->coeffErr[i][j] = 0.0;
+            poly->coeffMask[i][j] = PS_POLY_MASK_NONE;
+        }
+    }
+    return(true);
+}
+
+// XXX 3D, 4D versions
+psPolynomial1D *psPolynomial1DCopy(psPolynomial1D *out,
+                                   psPolynomial1D *poly)
+{
+    if (out == NULL) {
+        out = psPolynomial1DAlloc (poly->type, poly->nX);
+    } else {
+        psPolynomial1DRecycle (out, poly->type, poly->nX);
+    }
+
+    for (int i = 0; i < (1 + poly->nX); i++) {
+        out->coeff[i] = poly->coeff[i];
+        out->coeffErr[i] = poly->coeffErr[i];
+        out->coeffMask[i] = poly->coeffMask[i];
+    }
+    return(out);
+}
+psPolynomial2D *psPolynomial2DCopy(psPolynomial2D *out,
+                                   psPolynomial2D *poly)
+{
+    if (out == NULL) {
+        out = psPolynomial2DAlloc (poly->type, poly->nX, poly->nY);
+    } else {
+        psPolynomial2DRecycle (out, poly->type, poly->nX, poly->nY);
+    }
+
+    for (int i = 0; i < (1 + poly->nX); i++) {
+        for (int j = 0; j < (1 + poly->nY); j++) {
+            out->coeff[i][j] = poly->coeff[i][j];
+            out->coeffErr[i][j] = poly->coeffErr[i][j];
+            out->coeffMask[i][j] = poly->coeffMask[i][j];
+        }
+    }
+    return(out);
+}
+
 /* note these functions accept unscaled values and apply the scaling saved on poly */
 psF64 psPolynomial1DEval(const psPolynomial1D* poly,