| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| /* |
| * fpix1.c |
| * |
| * This file has basic constructors, destructors and field accessors |
| * for FPix and DPix. |
| * |
| * FPix Create/copy/destroy |
| * FPIX *fpixCreate() |
| * FPIX *fpixCreateTemplate() |
| * FPIX *fpixClone() |
| * FPIX *fpixCopy() |
| * l_int32 fpixResizeImageData() |
| * void fpixDestroy() |
| * |
| * FPix accessors |
| * l_int32 fpixGetDimensions() |
| * l_int32 fpixSetDimensions() |
| * l_int32 fpixGetWpl() |
| * l_int32 fpixSetWpl() |
| * l_int32 fpixGetRefcount() |
| * l_int32 fpixChangeRefcount() |
| * l_int32 fpixGetResolution() |
| * l_int32 fpixSetResolution() |
| * l_int32 fpixCopyResolution() |
| * l_float32 *fpixGetData() |
| * l_int32 fpixSetData() |
| * |
| * DPix Create/copy/destroy |
| * DPIX *dpixCreate() |
| * DPIX *dpixCreateTemplate() |
| * DPIX *dpixClone() |
| * DPIX *dpixCopy() |
| * l_int32 dpixResizeImageData() |
| * void dpixDestroy() |
| * |
| * DPix accessors |
| * l_int32 dpixGetDimensions() |
| * l_int32 dpixSetDimensions() |
| * l_int32 dpixGetWpl() |
| * l_int32 dpixSetWpl() |
| * l_int32 dpixGetRefcount() |
| * l_int32 dpixChangeRefcount() |
| * l_int32 dpixGetResolution() |
| * l_int32 dpixSetResolution() |
| * l_int32 dpixCopyResolution() |
| * l_float64 *dpixGetData() |
| * l_int32 dpixSetData() |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "allheaders.h" |
| |
| |
| /*--------------------------------------------------------------------* |
| * FPix Create/copy/destroy * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * fpixCreate() |
| * |
| * Input: width, height |
| * Return: fpixd (with data allocated and initialized to 0), |
| * or null on error |
| * |
| * Notes: |
| * (1) Makes a FPix of specified size, with the data array |
| * allocated and initialized to 0. |
| */ |
| FPIX * |
| fpixCreate(l_int32 width, |
| l_int32 height) |
| { |
| l_float32 *data; |
| FPIX *fpixd; |
| |
| PROCNAME("fpixCreate"); |
| |
| if (width <= 0) |
| return (FPIX *)ERROR_PTR("width must be > 0", procName, NULL); |
| if (height <= 0) |
| return (FPIX *)ERROR_PTR("height must be > 0", procName, NULL); |
| |
| if ((fpixd = (FPIX *)CALLOC(1, sizeof(FPIX))) == NULL) |
| return (FPIX *)ERROR_PTR("CALLOC fail for fpixd", procName, NULL); |
| fpixSetDimensions(fpixd, width, height); |
| fpixSetWpl(fpixd, width); |
| fpixd->refcount = 1; |
| |
| data = (l_float32 *)CALLOC(width * height, sizeof(l_float32)); |
| if (!data) |
| return (FPIX *)ERROR_PTR("CALLOC fail for data", procName, NULL); |
| fpixSetData(fpixd, data); |
| |
| return fpixd; |
| } |
| |
| |
| /*! |
| * fpixCreateTemplate() |
| * |
| * Input: fpixs |
| * Return: fpixd, or null on error |
| * |
| * Notes: |
| * (1) Makes a FPix of the same size as the input FPix, with the |
| * data array allocated and initialized to 0. |
| * (2) Copies the resolution. |
| */ |
| FPIX * |
| fpixCreateTemplate(FPIX *fpixs) |
| { |
| l_int32 w, h; |
| FPIX *fpixd; |
| |
| PROCNAME("fpixCreateTemplate"); |
| |
| if (!fpixs) |
| return (FPIX *)ERROR_PTR("fpixs not defined", procName, NULL); |
| |
| fpixGetDimensions(fpixs, &w, &h); |
| fpixd = fpixCreate(w, h); |
| fpixCopyResolution(fpixd, fpixs); |
| return fpixd; |
| } |
| |
| |
| /*! |
| * fpixClone() |
| * |
| * Input: fpix |
| * Return: same fpix (ptr), or null on error |
| * |
| * Notes: |
| * (1) See pixClone() for definition and usage. |
| */ |
| FPIX * |
| fpixClone(FPIX *fpix) |
| { |
| PROCNAME("fpixClone"); |
| |
| if (!fpix) |
| return (FPIX *)ERROR_PTR("fpix not defined", procName, NULL); |
| fpixChangeRefcount(fpix, 1); |
| |
| return fpix; |
| } |
| |
| |
| /*! |
| * fpixCopy() |
| * |
| * Input: fpixd (<optional>; can be null, or equal to fpixs, |
| * or different from fpixs) |
| * fpixs |
| * Return: fpixd, or null on error |
| * |
| * Notes: |
| * (1) There are three cases: |
| * (a) fpixd == null (makes a new fpix; refcount = 1) |
| * (b) fpixd == fpixs (no-op) |
| * (c) fpixd != fpixs (data copy; no change in refcount) |
| * If the refcount of fpixd > 1, case (c) will side-effect |
| * these handles. |
| * (2) The general pattern of use is: |
| * fpixd = fpixCopy(fpixd, fpixs); |
| * This will work for all three cases. |
| * For clarity when the case is known, you can use: |
| * (a) fpixd = fpixCopy(NULL, fpixs); |
| * (c) fpixCopy(fpixd, fpixs); |
| * (3) For case (c), we check if fpixs and fpixd are the same size. |
| * If so, the data is copied directly. |
| * Otherwise, the data is reallocated to the correct size |
| * and the copy proceeds. The refcount of fpixd is unchanged. |
| * (4) This operation, like all others that may involve a pre-existing |
| * fpixd, will side-effect any existing clones of fpixd. |
| */ |
| FPIX * |
| fpixCopy(FPIX *fpixd, /* can be null */ |
| FPIX *fpixs) |
| { |
| l_int32 w, h, bytes; |
| l_float32 *datas, *datad; |
| |
| PROCNAME("fpixCopy"); |
| |
| if (!fpixs) |
| return (FPIX *)ERROR_PTR("fpixs not defined", procName, NULL); |
| if (fpixs == fpixd) |
| return fpixd; |
| |
| /* Total bytes in image data */ |
| fpixGetDimensions(fpixs, &w, &h); |
| bytes = 4 * w * h; |
| |
| /* If we're making a new fpix ... */ |
| if (!fpixd) { |
| if ((fpixd = fpixCreateTemplate(fpixs)) == NULL) |
| return (FPIX *)ERROR_PTR("fpixd not made", procName, NULL); |
| datas = fpixGetData(fpixs); |
| datad = fpixGetData(fpixd); |
| memcpy((char *)datad, (char *)datas, bytes); |
| return fpixd; |
| } |
| |
| /* Reallocate image data if sizes are different */ |
| fpixResizeImageData(fpixd, fpixs); |
| |
| /* Copy data */ |
| fpixCopyResolution(fpixd, fpixs); |
| datas = fpixGetData(fpixs); |
| datad = fpixGetData(fpixd); |
| memcpy((char*)datad, (char*)datas, bytes); |
| return fpixd; |
| } |
| |
| |
| /*! |
| * fpixResizeImageData() |
| * |
| * Input: fpixd, fpixs |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| fpixResizeImageData(FPIX *fpixd, |
| FPIX *fpixs) |
| { |
| l_int32 ws, hs, wd, hd, bytes; |
| l_float32 *data; |
| |
| PROCNAME("fpixResizeImageData"); |
| |
| if (!fpixs) |
| return ERROR_INT("fpixs not defined", procName, 1); |
| if (!fpixd) |
| return ERROR_INT("fpixd not defined", procName, 1); |
| |
| fpixGetDimensions(fpixs, &ws, &hs); |
| fpixGetDimensions(fpixd, &wd, &hd); |
| if (ws == wd && hs == hd) /* nothing to do */ |
| return 0; |
| |
| fpixSetDimensions(fpixd, ws, hs); |
| fpixSetWpl(fpixd, ws); |
| bytes = 4 * ws * hs; |
| data = fpixGetData(fpixd); |
| if (data) FREE(data); |
| if ((data = (l_float32 *)MALLOC(bytes)) == NULL) |
| return ERROR_INT("MALLOC fail for data", procName, 1); |
| fpixSetData(fpixd, data); |
| return 0; |
| } |
| |
| |
| /*! |
| * fpixDestroy() |
| * |
| * Input: &fpix <will be nulled> |
| * Return: void |
| * |
| * Notes: |
| * (1) Decrements the ref count and, if 0, destroys the fpix. |
| * (2) Always nulls the input ptr. |
| */ |
| void |
| fpixDestroy(FPIX **pfpix) |
| { |
| l_float32 *data; |
| FPIX *fpix; |
| |
| PROCNAME("fpixDestroy"); |
| |
| if (!pfpix) { |
| L_WARNING("ptr address is null!", procName); |
| return; |
| } |
| |
| if ((fpix = *pfpix) == NULL) |
| return; |
| |
| /* Decrement the ref count. If it is 0, destroy the fpix. */ |
| fpixChangeRefcount(fpix, -1); |
| if (fpixGetRefcount(fpix) <= 0) { |
| if ((data = fpixGetData(fpix)) != NULL) |
| FREE(data); |
| FREE(fpix); |
| } |
| |
| *pfpix = NULL; |
| return; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * FPix Accessors * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * fpixGetDimensions() |
| * |
| * Input: fpix |
| * &w, &h (<optional return>; each can be null) |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| fpixGetDimensions(FPIX *fpix, |
| l_int32 *pw, |
| l_int32 *ph) |
| { |
| PROCNAME("fpixGetDimensions"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| if (pw) *pw = fpix->w; |
| if (ph) *ph = fpix->h; |
| return 0; |
| } |
| |
| |
| /*! |
| * fpixSetDimensions() |
| * |
| * Input: fpix |
| * w, h |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| fpixSetDimensions(FPIX *fpix, |
| l_int32 w, |
| l_int32 h) |
| { |
| PROCNAME("fpixSetDimensions"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| fpix->w = w; |
| fpix->h = h; |
| return 0; |
| } |
| |
| |
| l_int32 |
| fpixGetWpl(FPIX *fpix) |
| { |
| PROCNAME("fpixGetWpl"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| return fpix->wpl; |
| } |
| |
| |
| l_int32 |
| fpixSetWpl(FPIX *fpix, |
| l_int32 wpl) |
| { |
| PROCNAME("fpixSetWpl"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| |
| fpix->wpl = wpl; |
| return 0; |
| } |
| |
| |
| l_int32 |
| fpixGetRefcount(FPIX *fpix) |
| { |
| PROCNAME("fpixGetRefcount"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, UNDEF); |
| return fpix->refcount; |
| } |
| |
| |
| l_int32 |
| fpixChangeRefcount(FPIX *fpix, |
| l_int32 delta) |
| { |
| PROCNAME("fpixChangeRefcount"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| |
| fpix->refcount += delta; |
| return 0; |
| } |
| |
| |
| l_int32 |
| fpixGetResolution(FPIX *fpix, |
| l_int32 *pxres, |
| l_int32 *pyres) |
| { |
| PROCNAME("fpixGetResolution"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| if (pxres) *pxres = fpix->xres; |
| if (pyres) *pyres = fpix->yres; |
| return 0; |
| } |
| |
| |
| l_int32 |
| fpixSetResolution(FPIX *fpix, |
| l_int32 xres, |
| l_int32 yres) |
| { |
| PROCNAME("fpixSetResolution"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| |
| fpix->xres = xres; |
| fpix->yres = yres; |
| return 0; |
| } |
| |
| |
| l_int32 |
| fpixCopyResolution(FPIX *fpixd, |
| FPIX *fpixs) |
| { |
| l_int32 xres, yres; |
| PROCNAME("fpixCopyResolution"); |
| |
| if (!fpixs || !fpixd) |
| return ERROR_INT("fpixs and fpixd not both defined", procName, 1); |
| |
| fpixGetResolution(fpixs, &xres, &yres); |
| fpixSetResolution(fpixd, xres, yres); |
| return 0; |
| } |
| |
| |
| l_float32 * |
| fpixGetData(FPIX *fpix) |
| { |
| PROCNAME("fpixGetData"); |
| |
| if (!fpix) |
| return (l_float32 *)ERROR_PTR("fpix not defined", procName, NULL); |
| return fpix->data; |
| } |
| |
| |
| l_int32 |
| fpixSetData(FPIX *fpix, |
| l_float32 *data) |
| { |
| PROCNAME("fpixSetData"); |
| |
| if (!fpix) |
| return ERROR_INT("fpix not defined", procName, 1); |
| |
| fpix->data = data; |
| return 0; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * DPix Create/copy/destroy * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * dpixCreate() |
| * |
| * Input: width, height |
| * Return: dpix (with data allocated and initialized to 0), |
| * or null on error |
| * |
| * Notes: |
| * (1) Makes a DPix of specified size, with the data array |
| * allocated and initialized to 0. |
| */ |
| DPIX * |
| dpixCreate(l_int32 width, |
| l_int32 height) |
| { |
| l_float64 *data; |
| DPIX *dpix; |
| |
| PROCNAME("dpixCreate"); |
| |
| if (width <= 0) |
| return (DPIX *)ERROR_PTR("width must be > 0", procName, NULL); |
| if (height <= 0) |
| return (DPIX *)ERROR_PTR("height must be > 0", procName, NULL); |
| |
| if ((dpix = (DPIX *)CALLOC(1, sizeof(DPIX))) == NULL) |
| return (DPIX *)ERROR_PTR("CALLOC fail for dpix", procName, NULL); |
| dpixSetDimensions(dpix, width, height); |
| dpixSetWpl(dpix, width); |
| dpix->refcount = 1; |
| |
| data = (l_float64 *)CALLOC(width * height, sizeof(l_float64)); |
| if (!data) |
| return (DPIX *)ERROR_PTR("CALLOC fail for data", procName, NULL); |
| dpixSetData(dpix, data); |
| |
| return dpix; |
| } |
| |
| |
| /*! |
| * dpixCreateTemplate() |
| * |
| * Input: dpixs |
| * Return: dpixd, or null on error |
| * |
| * Notes: |
| * (1) Makes a DPix of the same size as the input DPix, with the |
| * data array allocated and initialized to 0. |
| * (2) Copies the resolution. |
| */ |
| DPIX * |
| dpixCreateTemplate(DPIX *dpixs) |
| { |
| l_int32 w, h; |
| DPIX *dpixd; |
| |
| PROCNAME("dpixCreateTemplate"); |
| |
| if (!dpixs) |
| return (DPIX *)ERROR_PTR("dpixs not defined", procName, NULL); |
| |
| dpixGetDimensions(dpixs, &w, &h); |
| dpixd = dpixCreate(w, h); |
| dpixCopyResolution(dpixd, dpixs); |
| return dpixd; |
| } |
| |
| |
| /*! |
| * dpixClone() |
| * |
| * Input: dpix |
| * Return: same dpix (ptr), or null on error |
| * |
| * Notes: |
| * (1) See pixClone() for definition and usage. |
| */ |
| DPIX * |
| dpixClone(DPIX *dpix) |
| { |
| PROCNAME("dpixClone"); |
| |
| if (!dpix) |
| return (DPIX *)ERROR_PTR("dpix not defined", procName, NULL); |
| dpixChangeRefcount(dpix, 1); |
| |
| return dpix; |
| } |
| |
| |
| /*! |
| * dpixCopy() |
| * |
| * Input: dpixd (<optional>; can be null, or equal to dpixs, |
| * or different from dpixs) |
| * dpixs |
| * Return: dpixd, or null on error |
| * |
| * Notes: |
| * (1) There are three cases: |
| * (a) dpixd == null (makes a new dpix; refcount = 1) |
| * (b) dpixd == dpixs (no-op) |
| * (c) dpixd != dpixs (data copy; no change in refcount) |
| * If the refcount of dpixd > 1, case (c) will side-effect |
| * these handles. |
| * (2) The general pattern of use is: |
| * dpixd = dpixCopy(dpixd, dpixs); |
| * This will work for all three cases. |
| * For clarity when the case is known, you can use: |
| * (a) dpixd = dpixCopy(NULL, dpixs); |
| * (c) dpixCopy(dpixd, dpixs); |
| * (3) For case (c), we check if dpixs and dpixd are the same size. |
| * If so, the data is copied directly. |
| * Otherwise, the data is reallocated to the correct size |
| * and the copy proceeds. The refcount of dpixd is unchanged. |
| * (4) This operation, like all others that may involve a pre-existing |
| * dpixd, will side-effect any existing clones of dpixd. |
| */ |
| DPIX * |
| dpixCopy(DPIX *dpixd, /* can be null */ |
| DPIX *dpixs) |
| { |
| l_int32 w, h, bytes; |
| l_float64 *datas, *datad; |
| |
| PROCNAME("dpixCopy"); |
| |
| if (!dpixs) |
| return (DPIX *)ERROR_PTR("dpixs not defined", procName, NULL); |
| if (dpixs == dpixd) |
| return dpixd; |
| |
| /* Total bytes in image data */ |
| dpixGetDimensions(dpixs, &w, &h); |
| bytes = 8 * w * h; |
| |
| /* If we're making a new dpix ... */ |
| if (!dpixd) { |
| if ((dpixd = dpixCreateTemplate(dpixs)) == NULL) |
| return (DPIX *)ERROR_PTR("dpixd not made", procName, NULL); |
| datas = dpixGetData(dpixs); |
| datad = dpixGetData(dpixd); |
| memcpy((char *)datad, (char *)datas, bytes); |
| return dpixd; |
| } |
| |
| /* Reallocate image data if sizes are different */ |
| dpixResizeImageData(dpixd, dpixs); |
| |
| /* Copy data */ |
| dpixCopyResolution(dpixd, dpixs); |
| datas = dpixGetData(dpixs); |
| datad = dpixGetData(dpixd); |
| memcpy((char*)datad, (char*)datas, bytes); |
| return dpixd; |
| } |
| |
| |
| /*! |
| * dpixResizeImageData() |
| * |
| * Input: dpixd, dpixs |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| dpixResizeImageData(DPIX *dpixd, |
| DPIX *dpixs) |
| { |
| l_int32 ws, hs, wd, hd, bytes; |
| l_float64 *data; |
| |
| PROCNAME("dpixResizeImageData"); |
| |
| if (!dpixs) |
| return ERROR_INT("dpixs not defined", procName, 1); |
| if (!dpixd) |
| return ERROR_INT("dpixd not defined", procName, 1); |
| |
| dpixGetDimensions(dpixs, &ws, &hs); |
| dpixGetDimensions(dpixd, &wd, &hd); |
| if (ws == wd && hs == hd) /* nothing to do */ |
| return 0; |
| |
| dpixSetDimensions(dpixd, ws, hs); |
| dpixSetWpl(dpixd, ws); |
| bytes = 8 * ws * hs; |
| data = dpixGetData(dpixd); |
| if (data) FREE(data); |
| if ((data = (l_float64 *)MALLOC(bytes)) == NULL) |
| return ERROR_INT("MALLOC fail for data", procName, 1); |
| dpixSetData(dpixd, data); |
| return 0; |
| } |
| |
| |
| /*! |
| * dpixDestroy() |
| * |
| * Input: &dpix <will be nulled> |
| * Return: void |
| * |
| * Notes: |
| * (1) Decrements the ref count and, if 0, destroys the dpix. |
| * (2) Always nulls the input ptr. |
| */ |
| void |
| dpixDestroy(DPIX **pdpix) |
| { |
| l_float64 *data; |
| DPIX *dpix; |
| |
| PROCNAME("dpixDestroy"); |
| |
| if (!pdpix) { |
| L_WARNING("ptr address is null!", procName); |
| return; |
| } |
| |
| if ((dpix = *pdpix) == NULL) |
| return; |
| |
| /* Decrement the ref count. If it is 0, destroy the dpix. */ |
| dpixChangeRefcount(dpix, -1); |
| if (dpixGetRefcount(dpix) <= 0) { |
| if ((data = dpixGetData(dpix)) != NULL) |
| FREE(data); |
| FREE(dpix); |
| } |
| |
| *pdpix = NULL; |
| return; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * DPix Accessors * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * dpixGetDimensions() |
| * |
| * Input: dpix |
| * &w, &h (<optional return>; each can be null) |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| dpixGetDimensions(DPIX *dpix, |
| l_int32 *pw, |
| l_int32 *ph) |
| { |
| PROCNAME("dpixGetDimensions"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| if (pw) *pw = dpix->w; |
| if (ph) *ph = dpix->h; |
| return 0; |
| } |
| |
| |
| /*! |
| * dpixSetDimensions() |
| * |
| * Input: dpix |
| * w, h |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| dpixSetDimensions(DPIX *dpix, |
| l_int32 w, |
| l_int32 h) |
| { |
| PROCNAME("dpixSetDimensions"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| dpix->w = w; |
| dpix->h = h; |
| return 0; |
| } |
| |
| |
| l_int32 |
| dpixGetWpl(DPIX *dpix) |
| { |
| PROCNAME("dpixGetWpl"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| return dpix->wpl; |
| } |
| |
| |
| l_int32 |
| dpixSetWpl(DPIX *dpix, |
| l_int32 wpl) |
| { |
| PROCNAME("dpixSetWpl"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| |
| dpix->wpl = wpl; |
| return 0; |
| } |
| |
| |
| l_int32 |
| dpixGetRefcount(DPIX *dpix) |
| { |
| PROCNAME("dpixGetRefcount"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, UNDEF); |
| return dpix->refcount; |
| } |
| |
| |
| l_int32 |
| dpixChangeRefcount(DPIX *dpix, |
| l_int32 delta) |
| { |
| PROCNAME("dpixChangeRefcount"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| |
| dpix->refcount += delta; |
| return 0; |
| } |
| |
| |
| l_int32 |
| dpixGetResolution(DPIX *dpix, |
| l_int32 *pxres, |
| l_int32 *pyres) |
| { |
| PROCNAME("dpixGetResolution"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| if (pxres) *pxres = dpix->xres; |
| if (pyres) *pyres = dpix->yres; |
| return 0; |
| } |
| |
| |
| l_int32 |
| dpixSetResolution(DPIX *dpix, |
| l_int32 xres, |
| l_int32 yres) |
| { |
| PROCNAME("dpixSetResolution"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| |
| dpix->xres = xres; |
| dpix->yres = yres; |
| return 0; |
| } |
| |
| |
| l_int32 |
| dpixCopyResolution(DPIX *dpixd, |
| DPIX *dpixs) |
| { |
| l_int32 xres, yres; |
| PROCNAME("dpixCopyResolution"); |
| |
| if (!dpixs || !dpixd) |
| return ERROR_INT("dpixs and dpixd not both defined", procName, 1); |
| |
| dpixGetResolution(dpixs, &xres, &yres); |
| dpixSetResolution(dpixd, xres, yres); |
| return 0; |
| } |
| |
| |
| l_float64 * |
| dpixGetData(DPIX *dpix) |
| { |
| PROCNAME("dpixGetData"); |
| |
| if (!dpix) |
| return (l_float64 *)ERROR_PTR("dpix not defined", procName, NULL); |
| return dpix->data; |
| } |
| |
| |
| l_int32 |
| dpixSetData(DPIX *dpix, |
| l_float64 *data) |
| { |
| PROCNAME("dpixSetData"); |
| |
| if (!dpix) |
| return ERROR_INT("dpix not defined", procName, 1); |
| |
| dpix->data = data; |
| return 0; |
| } |
| |
| |
