aboutsummaryrefslogtreecommitdiff
path: root/vendor/x11iraf/obm/ObmW/GtermMapping.c
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/x11iraf/obm/ObmW/GtermMapping.c')
-rw-r--r--vendor/x11iraf/obm/ObmW/GtermMapping.c2189
1 files changed, 2189 insertions, 0 deletions
diff --git a/vendor/x11iraf/obm/ObmW/GtermMapping.c b/vendor/x11iraf/obm/ObmW/GtermMapping.c
new file mode 100644
index 00000000..21e4760d
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/GtermMapping.c
@@ -0,0 +1,2189 @@
+
+
+
+/* refresh_source -- Refresh a portion of a mapping given the source rect
+ * to be refreshed. If the given source rect is not within the mapping,
+ * this is a no-op.
+ */
+static
+refresh_source (w, mp, x1, y1, nx, ny)
+ GtermWidget w;
+ register Mapping mp; /* mapping defining refresh operation */
+ int x1, y1, nx, ny; /* region of source to be refreshed */
+{
+ int sx1, sx2, sy1, sy2, snx, sny;
+ int dx1, dx2, dy1, dy2, dnx, dny;
+ int valid;
+
+
+ /* Do nothing if mapping not defined and enabled.
+ */
+ if (!(valid = valid_mapping (w, mp))) {
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_source: valid=%d\n", valid);
+ return (ERR);
+ }
+ if (!mp->enabled) {
+ if (DBG_TRACE)
+ fprintf (stderr, "ERROR ref_src: mapping %d not enabled\n",
+ mp->mapping);
+ return (OK);
+ }
+
+ /* Compute the intersection of the modified region of the source raster
+ ** with the rectangular region of the source raster affected by the given
+ ** mapping.
+ */
+ sx1 = max (x1, mp->sx);
+ sy1 = max (y1, mp->sy);
+ sx2 = min(x1 + nx, mp->sx + mp->snx) - 1;
+ sy2 = min(y1 + ny, mp->sy + mp->sny) - 1;
+ snx = sx2 - sx1 + 1;
+ sny = sy2 - sy1 + 1;
+
+ /* Do nothing if the rectangles do not intersect.
+ */
+ if (snx <= 0 || sny <= 0)
+ return (OK);
+
+ /* Compute the destination rect affected by the mapped source rect.
+ */
+ dx1 = mp->x_extent[sx1 - mp->sx].lo;
+ dx2 = mp->x_extent[sx2 - mp->sx].hi;
+ if (dx1 > dx2) {
+ dx1 = mp->x_extent[sx2 - mp->sx].lo;
+ dx2 = mp->x_extent[sx1 - mp->sx].hi;
+ }
+
+ dy1 = mp->y_extent[sy1 - mp->sy].lo;
+ dy2 = mp->y_extent[sy2 - mp->sy].hi;
+ if (dy1 > dy2) {
+ dy1 = mp->y_extent[sy2 - mp->sy].lo;
+ dy2 = mp->y_extent[sy1 - mp->sy].hi;
+ }
+
+ dnx = dx2 - dx1 + 1;
+ dny = dy2 - dy1 + 1;
+
+ if (CacheXImage) /* MF004 */
+ DestroyCachedXImage(); /* MF004 */
+
+ if (DBG_TRACE) {
+ fprintf(stderr, "refresh_source -- refreshing src (%d,%d) (%d,%d)\n",
+ sx1, sy1, snx, sny);
+ fprintf(stderr, "refresh_source -- refreshing dest (%d,%d) (%d,%d)\n",
+ dx1, dy1, dnx, dny);
+ dbg_printMappings (w);
+ }
+
+ /* Perform the refresh operation. */
+ return (refresh_destination (w, mp, dx1, dy1, dnx, dny));
+}
+
+
+/* refresh_destination -- Refresh (redraw) the pixels in the given destination
+ * rect. The mapping operand defines how to generate the value of each output
+ * pixel. This is the routine which does all the real work of a mapping,
+ * computing the values of the output pixels and writing to the destination
+ * drawable. Note: the destination rect must be specified in raster pixel
+ * coordinates (no NDC).
+ */
+static
+refresh_destination (w, mp, x1, y1, nx, ny)
+ GtermWidget w;
+ Mapping mp; /* mapping defining refresh operation */
+ int x1, y1, nx, ny; /* region of destination to be refreshed */
+{
+ Raster sr, dr, pr;
+ Display *display = w->gterm.display;
+ int scaling, xflip, yflip, delxin=0, delxout=0;
+ int ox, oy, rop, clip, mapping, i, j;
+ int src, st, sx, sy, snx, sny;
+ int dst, dt, dx, dy, dnx, dny;
+ int xoff, yoff, p1, p2, q1, q2;
+ float xscale, yscale;
+ struct mapping *np, p_mp;
+ XImage *xin, *xout;
+ int status = OK;
+ Pixmap pixmap; /* MF004 */
+
+ Region clip_region, mask_region;
+ uchar *old_xin_lp, *old_xout_lp;
+ uchar *xin_lp, *xout_lp, *op;
+ int xin_bpl, xout_bpl;
+ int *xmap, *ymap, valid;
+ XRectangle r;
+ XImage *img1 = (XImage *) NULL,
+ *img2 = (XImage *) NULL,
+ *img3 = (XImage *) NULL,
+ *img4 = (XImage *) NULL,
+ *img5 = (XImage *) NULL;
+
+
+
+ if (DBG_TRACE)
+ fprintf(stderr, "refresh_destination ENTER[0x%x]: pos=%d,%d sz=%d,%d\n",
+ w, x1,y1,nx,ny);
+
+ if (!w || !XtIsRealized ((Widget)w))
+ return (OK);
+
+ /* Do nothing if mapping not defined and enabled. */
+ if (!(valid = valid_mapping (w, mp))) {
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_destination: valid=%d\n", valid);
+ return (ERR);
+ }
+ if (!mp->enabled) {
+ if (DBG_TRACE)
+ fprintf (stderr, "ERROR ref_dst: mapping %d not enabled\n",
+ mp->mapping);
+ return (OK);
+ }
+
+
+ if (DBG_CMAPS && DBG_CM_VERB)
+ dbg_printCmaps (w);
+ if (DBG_TRACE)
+ dbg_printRasters (w);
+
+
+ /* Offsets into the x_*,y_* mapping lookup tables. */
+ xoff = x1 - mp->dx;
+ yoff = y1 - mp->dy;
+
+ /* Get source and destination rects. */
+ dst = mp->dst;
+ dx = x1; dy = y1;
+ dnx = nx; dny = ny;
+
+ src = mp->src;
+ p1 = mp->x_srcpix[xoff];
+ q1 = mp->y_srcpix[yoff];
+ p2 = mp->x_srcpix[xoff + nx - 1];
+ q2 = mp->y_srcpix[yoff + ny - 1];
+ sx = min (p1, p2);
+ sy = min (q1, q2);
+ snx = abs (p2 - p1) + 1;
+ sny = abs (q2 - q1) + 1;
+
+ /* Define some local variables. */
+ sr = &w->gterm.rasters[src];
+ dr = &w->gterm.rasters[dst];
+ pr = &w->gterm.rasters[0]; /* display pixmap raster */
+ mapping = mp->mapping;
+ scaling = mp->scaling;
+ xscale = mp->xscale;
+ yscale = mp->yscale;
+ rop = mp->rop;
+
+ if (DBG_TRACE) {
+ fprintf (stderr,
+ "refresh_destination: src,dst = %d,%d st,dt = %s[%d],%s[%d]\n",
+ src, dst,
+ (sr->type == 1 ? "image" : "pixmap"), sr->depth,
+ (dr->type == 1 ? "image" : "pixmap"), dr->depth);
+ fprintf (stderr,
+ "refresh: gterm.pixmap=0x%x src.pixmap=0x%x dest.pixmap=0x%x\n",
+ w->gterm.pixmap, sr->r.pixmap, dr->r.pixmap);
+ fprintf (stderr,
+ "refresh: gterm.pixmap=0x%x src.ximage=0x%x dest.ximage=0x%x\n",
+ w->gterm.pixmap, sr->r.ximage, dr->r.ximage);
+ fprintf (stderr,
+ "refresh_destination: src=>(%d,%d : %d,%d) dst=>(%d,%d : %d,%d)\n",
+ sx, sy, snx, sny, dx, dy, dnx, dny);
+ }
+
+
+ /* Basic error checking.
+ */
+ if (!sr->type || !dr->type) {
+ if (DBG_TRACE)
+ fprintf (stderr, "ERROR: invalid src or dest type\n");
+ return (ERR);
+
+ } else if (snx <= 0 || sny <= 0 || dnx == 0 || dny == 0) {
+ if (DBG_TRACE)
+ fprintf (stderr, "ERROR: negative src position or zero size\n");
+ return (ERR);
+
+ } else if (src < 0 || src > w->gterm.maxRasters ||
+ dst < 0 || dst > w->gterm.maxRasters) {
+ if (DBG_TRACE)
+ fprintf (stderr, "ERROR: invalid src or dest value\n");
+ return (ERR);
+ }
+
+
+ /* Do we have a flip in X or Y? */
+ xflip = mp->dnx < 0;
+ yflip = mp->dny < 0;
+
+ /* Any higher numbered mappings which map to the same destination as the
+ * mapping MP will obscure the current mapping. Construct a clip mask
+ * defining the region of the destination we can write to. This will be
+ * the region not obscured by any higher numbered, active mappings.
+ */
+ clip = False;
+ clip_region = XCreateRegion();
+ r.x = dx;
+ r.y = dy;
+ r.width = dnx;
+ r.height = dny;
+#ifdef sun
+ /* As far as I can tell the Sun (probably in the OW X server) has an
+ * off by one bug affecting clipping in the server. A clip region is
+ * too small by one pixel at the right and bottom, causing these pixels
+ * to not be written when refreshing the screen (usually this shows up
+ * as black lines on the screen when a region is refreshed). So far
+ * I haven't seen this on any other platform. The problem is imperfectly
+ * understood and the following workaround may not completely workaround
+ * the problem.
+ */
+ r.width++; r.height++;
+#endif
+ XUnionRectWithRegion (&r, clip_region, clip_region);
+
+ for (np = mp->next; np; np = np->next) {
+ struct mapping p_np;
+
+ if (!np->enabled || np->dst != dst)
+ continue;
+ get_pixel_mapping (w, np, &p_np, 0);
+
+ r.x = p_np.dx; r.y = p_np.dy;
+ r.width = abs(p_np.dnx);
+ r.height = abs(p_np.dny);
+
+ if (XRectInRegion (clip_region,
+ r.x, r.y, r.width, r.height) != RectangleOut) {
+
+ mask_region = XCreateRegion();
+ XUnionRectWithRegion (&r, mask_region, mask_region);
+ XSubtractRegion (clip_region, mask_region, clip_region);
+ XDestroyRegion (mask_region);
+ clip++;
+ }
+ }
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: xflip=%d yflip=%d clip=%d scaling=%d\n",
+ xflip, yflip, clip, scaling);
+
+ if (clip && dr->type == PixmapRaster)
+ XSetRegion (w->gterm.display, w->gterm.exposeGC, clip_region);
+
+
+ /* Handle the special case of a pixmap to pixmap (or window) copy in
+ * the server with no scaling.
+ */
+ if (!scaling && sr->type == PixmapRaster && dr->type == PixmapRaster) {
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: pixmap-to-pixmap copy %d <-> %d\n",
+ src, dst);
+
+ if (src == 0 && dst == 0 && w->gterm.pixmap && !(rop & R_Transient)) {
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: pixmap copy src=dst=0\n");
+
+ XCopyArea (display,
+ w->gterm.pixmap, w->gterm.pixmap,
+ w->gterm.exposeGC, sx, sy, snx, sny, dx, dy);
+
+ XCopyArea (display,
+ GPMtoRPM(w, dr), dr->r.pixmap,
+ w->gterm.exposeGC, dx, dy, dnx, dny, dx, dy);
+
+ /* Update the root display shadow pixmap.
+ */
+ XCopyArea (display,
+ pr->shadow_pixmap, pr->shadow_pixmap,
+ w->gterm.expose8GC, sx, sy, snx, sny, dx, dy);
+
+ } else {
+ Raster rp = &w->gterm.rasters[src-1];
+
+ if (DBG_TRACE) {
+ fprintf (stderr,
+ "refresh_destination: pixmap copy src || dst != 0\n");
+ fprintf (stderr, "src=%d dest=%d shadow=0x%x ximage=0x%x\n",
+ src, dst, dr->shadow_pixmap, rp->r.ximage);
+ dbg_printRasters (w);
+ fprintf (stderr,
+ "src=%d,%d %d %d dest=%d,%d %d %d (src=%d dst=%d)\n",
+ sx, sy, snx, sny, dx, dy, dnx, dny, src, dst);
+ }
+
+ XCopyArea (display,
+ RPMtoRPM(sr, dr), dr->r.pixmap,
+ w->gterm.exposeGC, sx, sy, snx, sny, dx, dy);
+
+
+ /* Update the shadow pixmap.
+ */
+ XCopyArea (display,
+ sr->shadow_pixmap, dr->shadow_pixmap,
+ w->gterm.expose8GC, sx, sy, snx, sny, dx, dy);
+
+ if (dst == 0 && w->gterm.pixmap && !(rop & R_Transient))
+ XCopyArea (display,
+ RPMtoGPM (sr, w), w->gterm.pixmap,
+ w->gterm.exposeGC, sx, sy, snx, sny, dx, dy);
+ }
+
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: spec_case: pixmap copy no scaling\n");
+
+ goto done;
+ }
+
+ /* Any other case requires working on ximages in the client. The first
+ * step is to get the source ximage.
+ */
+ if (sr->type == PixmapRaster) {
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: source type is PixmapRaster[%d]\n", src);
+
+ /* Source is a pixmap but we need a local copy as either the
+ * destination is not a pixmap, or we need to do some scaling.
+ */
+ if (CacheXImage) { /* MF004 */
+ pixmap = (src || !w->gterm.pixmap) ? sr->r.pixmap : w->gterm.pixmap;
+
+ if (DBG_TRACE) {
+ fprintf (stderr, "refresh_destination: xin is cached XImage ");
+ fprintf (stderr, " src=%d pix=0x%x dims=%d,%d\n",
+ src, w->gterm.pixmap, sr->width, sr->height);
+ }
+
+ xin = GetCachedXImage (w, pixmap, sr->width, sr->height);
+ if (xin == NULL) {
+ xin = XGetImage (display, pixmap,
+ 0, 0, sr->width, sr->height, 0xff, ZPixmap);
+ if (xin == NULL) {
+ status = ERR;
+ goto done;
+ } else
+ NewCachedXImage (w, xin, pixmap, sr->width, sr->height);
+ }
+
+ } else { /* MF004 */
+
+ /*
+ */
+ if (w->gterm.w_depth > ColormapDepth) {
+ if (DBG_TRACE) {
+ fprintf (stderr,
+ "src=%d dst=%d d_ras=%d %d x %d pr=0x%x sr=0x%x\n",
+ src, dst, w->gterm.d_raster, sr->width, sr->height,
+ pr->shadow_pixmap, sr->shadow_pixmap);
+ dbg_printRasters (w);
+ }
+
+ xin = XGetImage (display, sr->shadow_pixmap,
+ 0, 0, sr->width, sr->height, 0xff, ZPixmap);
+
+ } else {
+ xin = XGetImage (display,
+ (src || !w->gterm.pixmap) ? sr->r.pixmap : w->gterm.pixmap,
+ 0, 0, sr->width, sr->height, 0xff, ZPixmap);
+ }
+
+ if (DBG_TRACE) {
+ fprintf (stderr, "refresh_destination: xin is drawable '%s'\n",
+ (src || !w->gterm.pixmap) ? "sr raster" : "gterm pixmap");
+ fprintf (stderr,
+ "refresh_destination: xin size=%d,%d bpp=%d bpl=%d\n",
+ xin->width, xin->height, xin->bits_per_pixel,
+ xin->bytes_per_line);
+ }
+
+ if (xin == NULL) {
+ status = ERR;
+ goto done;
+ }
+ delxin++;
+ } /* MF004 */
+
+ } else {
+ /* Source is an ximage. */
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: src type is XImage (sr->r.ximage)\n");
+
+ xin = sr->r.ximage;
+ }
+
+ /* Handle the special case of a copy of an ximage to an output pixmap
+ * with no scaling.
+ */
+ if (!scaling && dr->type == PixmapRaster) {
+
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_destination: NO scaling, dest=Pixmap\n");
+
+ if (dst == 0 && w->gterm.pixmap && !(rop & R_Transient)) {
+
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_destination: dest == 0\n");
+
+ XPutImage (display,
+ w->gterm.pixmap, w->gterm.exposeGC,
+ (img1=IMGtoGPM(w,xin,sx,sy,dnx,dny)),
+ sx, sy, dx, dy, dnx, dny);
+
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "\n\nrefresh: gterm.pixmap=0x%x dest.pixmap=0x%x\n\n",
+ w->gterm.pixmap, dr->r.pixmap);
+
+ XCopyArea (display,
+ GPMtoRPM (w, dr), dr->r.pixmap,
+ w->gterm.exposeGC, dx, dy, dnx, dny, dx, dy);
+
+ if (w->gterm.w_depth > ColormapDepth) {
+ XPutImage (display, pr->shadow_pixmap, w->gterm.expose8GC, xin,
+ sx, sy, dx, dy, dnx, dny);
+ }
+
+ } else {
+
+ if (DBG_TRACE) {
+ fprintf (stderr, "refresh_destination: xin dst > 0\n");
+ fprintf (stderr,
+ "refresh_destination: src=(%d,%d) => %d,%d : %d,%d\n",
+ sx, sy, dx, dy, dnx, dny);
+ fprintf (stderr,
+ "refresh_destination: dr->shadow_pixmap = 0x%x\n",
+ dr->shadow_pixmap);
+ fprintf (stderr, "refresh_destination: xin => %d x %d x %d\n",
+ xin->width, xin->height, xin->depth);
+ }
+
+ /* Copy the 'xin' to the 'dr->r.pixmap'
+ */
+ XPutImage (display,
+ dr->r.pixmap, w->gterm.exposeGC,
+ (img2=IMGtoRPM(w,xin,dr,sx,sy,dnx,dny)),
+ sx, sy, dx, dy, dnx, dny);
+
+
+ if (w->gterm.w_depth > ColormapDepth) {
+ XPutImage (display, dr->r.pixmap, w->gterm.exposeGC,
+ (img3=IMGtoRPM(w,xin,dr,sx,sy,dnx,dny)),
+ sx, sy, dx, dy, dnx, dny);
+
+ /* Shadow the pixmap with an 8-bit version for readback.
+ */
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "updating shadow_pixmap........................0x%x\n",
+ dr->shadow_pixmap);
+ XPutImage (display, dr->shadow_pixmap,
+ w->gterm.expose8GC, xin,
+ sx, sy, dx, dy, dnx, dny);
+ }
+ }
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: NO scaling, dest=Pixmap -- DONE\n");
+
+ goto done;
+ }
+
+ /* Get output ximage.
+ */
+ if (dr->type == ImageRaster) {
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: dest type is XImage (dr->r.ximage)\n");
+
+ xout = dr->r.ximage;
+ ox = dx;
+ oy = dy;
+
+ } else {
+
+ uchar *data = (uchar *) XtCalloc (dnx * dny, sizeof(uchar));
+
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: dest type is Pixmap, create XImage\n");
+
+ if (data == NULL) {
+ status = ERR;
+ goto done;
+ }
+
+ if (DBG_TRACE)
+ fprintf (stderr,
+ "refresh_destination: creating 8-bit ximage....%d x %d\n",
+ dnx, dny);
+
+ xout = XCreateImage (w->gterm.display, NULL, RasterDepth,
+ ZPixmap, 0, (char *)data, dnx, dny, 8, 0);
+
+ if (xout == NULL) {
+ XtFree ((char *)data);
+ status = ERR;
+ goto done;
+ }
+ ox = 0;
+ oy = 0;
+ delxout++;
+ }
+
+ xin_lp = (uchar *)xin->data;
+ xout_lp = (uchar *)xout->data;
+ xin_bpl = xin->bytes_per_line;
+ xout_bpl = xout->bytes_per_line;
+
+ /* Map a region of the input ximage XIN to the output ximage XOUT. Various
+ * approaches are used to generate the output data, depending upon what
+ * type of scaling we are doing.
+ */
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh: scaling=%d xin=0x%x xout=0x%x\n",
+ scaling, xin, xout);
+
+ if (!scaling) {
+ /* No scaling. Copy a region of the ximage xin to xout without
+ * spatially scaling the image data.
+ */
+ if (clip && dr->type == ImageRaster)
+ goto zoom;
+
+ xin_lp = (uchar *)xin->data + sy * xin_bpl + sx;
+ xout_lp = (uchar *)xout->data + oy * xout_bpl + ox;
+
+ for (j=0; j < dny; j++) {
+ memmove (xout_lp, xin_lp, dnx);
+ xin_lp += xin_bpl;
+ xout_lp += xout_bpl;
+ }
+
+ } else if (scaling == M_INTZOOM) {
+ /* Integer zoom. The zoom factor is an integer, allowing the zoomed
+ * image to be calculated without using the xmap,ymap lookup tables.
+ */
+ if (clip && dr->type == ImageRaster)
+ goto zoom;
+
+ scale_intzoom (xin_lp,xin_bpl, xout_lp,xout_bpl, sx,sy, ox,oy,dnx,dny,
+ xflip,yflip, (int)(xscale + 0.5), (int)(yscale + 0.5));
+
+ } else if (scaling == M_ZOOM) {
+ /* We have a zoom, or one-to-many, scaling. Zoom scaling is always
+ * done with pixel replication. The [xy]_srcpix arrays in the mapping
+ * descriptor give the source pixel corresponding to each mapped pixel
+ * in the destination raster.
+ */
+zoom:
+ xmap = &mp->x_srcpix[xoff];
+ ymap = &mp->y_srcpix[yoff];
+
+ scale_zoom (xin_lp, xin_bpl, xout_lp, xout_bpl,
+ xmap, ymap, ox, oy, dnx, dny,
+ (clip && dr->type == ImageRaster) ? clip_region : (Region)NULL);
+
+ } else if (scaling == M_DEZOOM) {
+ /* We have a dezoom, or many-to-one, scaling. A block of pixels in
+ * the input raster are combined to generate the value of each output
+ * pixel, using one of several antialias algorithms to compute the
+ * output pixel value.
+ */
+ float *x_src = &mp->x_src[xoff];
+ float *y_src = &mp->y_src[yoff];
+ int near_unitary = (xscale > 0.5 && yscale > 0.5);
+ int function;
+
+ /* Get the antialising function to be applied. */
+ if (!(function = (mp->rop & R_MFMask)))
+ function = MF_NEAREST;
+
+ /* If the dezoom factor is small and either MF_BILINEAR or
+ * MF_NEAREST is enabled, use the indicated method to sample the
+ * input data. This uses all the data but minimizes smoothing.
+ */
+ if ((function & (MF_BILINEAR|MF_NEAREST)) && near_unitary)
+ function = (function & MF_BILINEAR) ? MF_BILINEAR : MF_NEAREST;
+ else if (function != (function & (MF_BILINEAR|MF_NEAREST)))
+ function &= ~(MF_BILINEAR|MF_NEAREST);
+
+filter:
+ /* This can take a while so update the display. */
+ XFlush (w->gterm.display);
+
+ /* If the filtering operation involves any arithmetic combinations
+ * of pixels we must convert pixel numbers to pixel intensity values
+ * before performing the filtering operation. This is a case where
+ * we would be better off if frame buffers were maintained using
+ * pixel intensities rather than hardware pixel numbers.
+ */
+ if (function != MF_NEAREST) {
+ uchar *data = (uchar *) XtMalloc (xin->width * xin->height);
+ if (data == NULL) {
+ status = ERR;
+ goto done;
+ }
+
+ mf_getinten (w,
+ xin_lp, xin->width, xin->height, xin_bpl, sx,sy,
+ data, xin->width, xin->height, xin_bpl, sx,sy, snx,sny);
+
+ if (!delxin) {
+ xin = XCreateImage (w->gterm.display, NULL, RasterDepth,
+ ZPixmap, 0, (char *)data, xin->width, xin->height, 8, 0);
+ if (xin == NULL) {
+ XtFree ((char *)data);
+ status = ERR;
+ goto done;
+ }
+ delxin++;
+ } else {
+ XtFree ((char *)xin->data);
+ xin->data = (char *) data;
+ }
+ xin_lp = (uchar *)xin->data;
+ }
+
+ /* Filter the source rect to the destination.
+ */
+ switch (function) {
+ case MF_NEAREST:
+ scale_nearest (
+ xin_lp, xin->width, xin->height, xin_bpl,
+ xout_lp, xout->width, xout->height, xout_bpl,
+ x_src, y_src, ox, oy, dnx, dny,
+ (clip && dr->type == ImageRaster) ? clip_region : (Region)NULL
+ );
+ break;
+ case MF_BILINEAR:
+ scale_bilinear (
+ xin_lp, xin->width, xin->height, xin_bpl,
+ xout_lp, xout->width, xout->height, xout_bpl,
+ x_src, y_src, ox, oy, dnx, dny,
+ (clip && dr->type == ImageRaster) ? clip_region : (Region)NULL
+ );
+ break;
+ case MF_BLKAVG:
+ scale_boxcar (
+ xin_lp, xin->width, xin->height, xin_bpl,
+ xout_lp, xout->width, xout->height, xout_bpl,
+ x_src,y_src, sx,sy,snx,sny, ox,oy,dnx,dny,
+ xscale,yscale, 0, clip ? clip_region : (Region)NULL
+ );
+ break;
+ case MF_BOXCAR:
+ scale_boxcar (
+ xin_lp, xin->width, xin->height, xin_bpl,
+ xout_lp, xout->width, xout->height, xout_bpl,
+ x_src,y_src, sx,sy,snx,sny, ox,oy,dnx,dny,
+ xscale,yscale, 1, clip ? clip_region : (Region)NULL
+ );
+ break;
+ case MF_LOWPASS:
+ scale_lowpass (
+ xin_lp, xin->width, xin->height, xin_bpl,
+ xout_lp, xout->width, xout->height, xout_bpl,
+ x_src,y_src, sx,sy,snx,sny, ox,oy,dnx,dny,
+ xscale,yscale, clip ? clip_region : (Region)NULL
+ );
+ break;
+ default:
+ function = MF_BILINEAR;
+ goto filter;
+ }
+
+ /* If the operation was performed in intensity space convert back
+ * to pixel number.
+ */
+ if (function != MF_NEAREST)
+ mf_getpixel (w,
+ xout_lp, xout->width, xout->height, xout_bpl, ox,oy,
+ xout_lp, xout->width, xout->height, xout_bpl, ox,oy, dnx,dny);
+
+ } else {
+ status = ERR;
+ goto done;
+ }
+
+ /* Copy the scaled ximage to the output pixmap, if any.
+ */
+ if (dr->type == PixmapRaster) {
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_destination: COPY TO OUTPUT PIXMAP\n");
+
+ if (dst == 0 && w->gterm.pixmap && !(rop & R_Transient)) {
+
+ if (DBG_TRACE) {
+ fprintf (stderr, "refresh_destination: dst=0\n");
+ fprintf (stderr,
+ "refresh_destination: src=(%d,%d) => %d,%d : %d,%d\n",
+ ox, oy, dx, dy, dnx, dny);
+ }
+
+ XPutImage (display,
+ w->gterm.pixmap, w->gterm.exposeGC,
+ (img4=IMGtoGPM(w,xout,ox,oy,dnx,dny)),
+ ox, oy, dx, dy, dnx, dny);
+
+ XCopyArea (display,
+ GPMtoRPM (w, dr), dr->r.pixmap,
+ w->gterm.exposeGC, dx, dy, dnx, dny, dx, dy);
+
+ if (w->gterm.w_depth > ColormapDepth) {
+ if (DBG_TRACE) {
+ fprintf (stderr,
+ "updating shadow_pixmap........................0x%x\n",
+ dr->shadow_pixmap);
+ fprintf (stderr,
+ "updating %d,%d to %d,%d %d %d\n",
+ ox, oy, dx, dy, dnx, dny);
+ }
+ XPutImage (display, dr->shadow_pixmap,
+ w->gterm.expose8GC, xout, ox, oy, dx, dy, dnx, dny);
+ }
+
+ } else {
+
+ if (DBG_TRACE) {
+ fprintf (stderr, "refresh_destination: xout dst > 0\n");
+ fprintf (stderr,
+ "refresh_destination: src=(%d,%d) => %d,%d : %d,%d\n",
+ ox, oy, dx, dy, dnx, dny);
+ }
+
+ XPutImage (display,
+ dr->r.pixmap, w->gterm.exposeGC,
+ (img5=IMGtoRPM(w,xout,dr,ox,oy,dnx,dny)),
+ ox, oy, dx, dy, dnx, dny);
+
+ if (w->gterm.w_depth > ColormapDepth) {
+ /*
+ XPutImage (display, pr->r.pixmap, w->gterm.exposeGC, xout,
+ ox, oy, dx, dy, dnx, dny);
+ */
+
+ /* Shadow the pixmap with an 8-bit version for readback.
+ */
+ if (DBG_TRACE) {
+ fprintf (stderr,
+ "updating shadow_pixmap........................0x%x\n",
+ dr->shadow_pixmap);
+ fprintf (stderr,
+ "updating %d,%d to %d,%d %d %d\n",
+ ox, oy, dx, dy, dnx, dny);
+ }
+ XPutImage (display, dr->shadow_pixmap,
+ w->gterm.expose8GC, xout,
+ ox, oy, dx, dy, dnx, dny);
+ }
+ }
+ }
+
+done:
+ /* Clean up.
+ */
+ if (delxin) XDestroyImage (xin);
+ if (delxout) XDestroyImage (xout);
+
+ if (img1) XDestroyImage (img1);
+ if (img2) XDestroyImage (img2);
+ if (img3) XDestroyImage (img3);
+ if (img4) XDestroyImage (img4);
+ if (img5) XDestroyImage (img5);
+
+ XDestroyRegion (clip_region);
+ if (clip && dr->type == PixmapRaster)
+ XSetClipMask (w->gterm.display, w->gterm.exposeGC, None);
+
+ if (DBG_TRACE)
+ fprintf (stderr, "refresh_destination: doing mappings status=%d\n",
+ status);
+
+ /* Execute any mappings defined on the raster just updated. */
+ if (status == OK) {
+
+ GtRefreshPixels (w, dst, GtPixel, dx, dy, dnx, dny);
+
+ if (dst == 0) {
+ Region clip_region = (Region)NULL;
+ XRectangle r;
+
+ clip_region = XCreateRegion();
+ r.x = dx; r.y = dy;
+ r.width = dnx; r.height = dny;
+ XUnionRectWithRegion (&r, clip_region, clip_region);
+
+ update_transients (w, clip_region);
+ XDestroyRegion (clip_region);
+ }
+ }
+
+ if (DBG_TRACE)
+ fprintf(stderr, "refresh_destination: LEAVING status=%d\n", status);
+
+ return (status);
+}
+
+
+/* scale_zoom -- Compute the given destination rect from the input image,
+ * using pixel replication and the given x and y dst->scr pixels maps.
+ */
+static
+scale_zoom (idata,ibpl, odata,obpl, xmap,ymap, dx,dy,dnx,dny, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int ibpl, obpl; /* bytes per line */
+ register int *xmap; /* src coords of each dst pixel */
+ int *ymap; /* src coords of each dst pixel */
+ int dx, dy, dnx, dny; /* destination rect */
+ Region clip_region; /* clip Region or null */
+{
+ register int i, j;
+ register uchar *ip, *op;
+ uchar *last_ip = NULL;
+ uchar *last_op = NULL;
+
+ for (j=0; j < dny; j++) {
+ ip = idata + ymap[j] * ibpl;
+ op = odata + (j+dy) * obpl + dx;
+
+ if (!clip_region) {
+ if (ip == last_ip)
+ memmove (op, last_op, dnx);
+ else {
+ for (i=0; i < dnx; i++) {
+ op[i] = ip[xmap[i]];
+ }
+ }
+ last_ip = ip;
+ last_op = op;
+ } else {
+ for (i=0; i < dnx; i++)
+ if (XPointInRegion (clip_region, i + dx, j + dy))
+ op[i] = ip[xmap[i]];
+ }
+ }
+}
+
+
+/* scale_intzoom -- Compute the given destination rect from the input image,
+ * using pixel replication and integer scaling. This is functionally
+ * equivalent to scale_zoom using the lookup tables, but optimized for the
+ * case of integer scaling.
+ */
+static
+scale_intzoom (idata,ibpl,odata,obpl, sx,sy,dx,dy,dnx,dny, xflip,yflip, nx,ny)
+
+ uchar *idata, *odata; /* input, output data */
+ int ibpl, obpl; /* bytes per line */
+ int sx, sy; /* start coords of src rect */
+ int dx, dy, dnx, dny; /* destination rect */
+ int xflip, yflip; /* set if x or y is flipped */
+ int nx, ny; /* replication factors */
+{
+ register int n;
+ register int pix;
+ register uchar *ip, *op;
+ uchar *otop, *olast, *lp;
+ int i, j, k;
+
+ olast = odata + (dy + dny) * obpl - dnx + dx;
+
+ if (xflip) {
+ for (j=0, k=0; j < dny; j += ny, k++) {
+ ip = idata + (sy + k) * ibpl + sx;
+
+ op = odata + (dy + (yflip ? (dny-ny-j) : j)) * obpl + dx + dnx;
+ otop = lp = op - dnx;
+
+
+ /* Why are the case statements below necessary, doesn't the
+ * default case do the same thing regardless of what nx is? MJF
+ */
+
+ /* Replicate a block of pixels. */
+ switch (nx) {
+ case 2:
+ for (n = (dnx/2); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix;
+ }
+ break;
+ case 3:
+ for (n = (dnx/3); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix; *--op = pix;
+ }
+ break;
+ case 4:
+ for (n = (dnx/4); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ }
+ break;
+ case 5:
+ for (n = (dnx/5); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ }
+ break;
+ case 6:
+ for (n = (dnx/6); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix; *--op = pix;
+ }
+ break;
+ case 7:
+ for (n = (dnx/7); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ }
+ break;
+ case 8:
+ for (n = (dnx/8); --n >= 0; ) {
+ pix = *ip++;
+ *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ *--op = pix; *--op = pix;
+ }
+ break;
+ default:
+ for (n = (dnx/nx); --n >= 0; ) {
+ pix = *ip++;
+ for (i=nx; --i >= 0; )
+ *--op = pix;
+ }
+ break;
+ }
+
+ /* Fill the last partial pixel. */
+ pix = *ip++;
+ while (op > otop)
+ *--op = pix;
+
+ /* Replicate in Y. */
+ for (n=ny, op=lp; --n > 0; ) {
+ op += obpl;
+ if (op <= olast)
+ memmove (op, lp, dnx);
+ }
+ }
+ } else {
+ for (j=0, k=0; j < dny; j += ny, k++) {
+ ip = idata + (sy + k) * ibpl + sx;
+ op = lp = odata + (dy + (yflip ? (dny-ny-j) : j)) * obpl + dx;
+ otop = op + dnx;
+
+ /* Replicate a block of pixels. */
+ switch (nx) {
+ case 2:
+ for (n = (dnx/2); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 3:
+ for (n = (dnx/3); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 4:
+ for (n = (dnx/4); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 5:
+ for (n = (dnx/5); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 6:
+ for (n = (dnx/6); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 7:
+ for (n = (dnx/7); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ }
+ break;
+ case 8:
+ for (n = (dnx/8); --n >= 0; ) {
+ pix = *ip++;
+ *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ *op++ = pix; *op++ = pix;
+ }
+ break;
+ default:
+ for (n = (dnx/nx); --n >= 0; ) {
+ pix = *ip++;
+ for (i=nx; --i >= 0; )
+ *op++ = pix;
+ }
+ break;
+ }
+
+ /* Fill the last partial pixel. */
+ pix = *ip++;
+ while (op < otop)
+ *op++ = pix;
+
+ /* Replicate in Y. */
+ for (n=ny, op=lp; --n > 0; ) {
+ op += obpl;
+ if (op <= olast)
+ memmove (op, lp, dnx);
+ }
+ }
+ }
+}
+
+
+/* scale_nearest -- Compute the given destination rect from the input image,
+ * using the nearest neighbor technique.
+ */
+static
+scale_nearest (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, dx,dy,dnx,dny, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* dimensions of input array */
+ int onx, ony, obpl; /* dimensions of output array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int dx, dy, dnx, dny; /* destination rect */
+ Region clip_region; /* clip Region or null */
+{
+ register int m, n, i, j;
+ register uchar *op;
+
+ for (j=0; j < dny; j++) {
+ op = odata + (j+dy) * obpl + dx;
+ n = y_src[j];
+
+ if (!clip_region) {
+ for (i=0; i < dnx; i++) {
+ m = x_src[i];
+ op[i] = idata[n * ibpl + m];
+ }
+ } else {
+ for (i=0; i < dnx; i++)
+ if (XPointInRegion (clip_region, i + dx, j + dy)) {
+ m = x_src[i];
+ op[i] = idata[n * ibpl + m];
+ }
+ }
+ }
+}
+
+
+/* scale_bilinear -- Compute the given destination rect from the input image,
+ * using bilinear interpolation.
+ */
+static
+scale_bilinear (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, dx,dy,dnx,dny, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* dimensions of input array */
+ int onx, ony, obpl; /* dimensions of output array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int dx, dy, dnx, dny; /* destination rect */
+ Region clip_region; /* clip Region or null */
+{
+ register int i;
+ register uchar *op;
+ register float *lp, *w1, *w2;
+ int buflen, line, *px, pixel, j;
+ float lo_w, hi_w, x, y;
+ uchar *lo, *hi;
+ float *buf;
+
+ buflen = (3 * dnx + 2) * sizeof(float) + dnx * sizeof(int);
+ if ((buf = (float *) XtMalloc (buflen)) == NULL)
+ return;
+
+ lp = buf + 1;
+ w1 = lp + dnx + 1;
+ w2 = w1 + dnx;
+ px = (int *)(w2 + dnx);
+
+ /* Compute the weight vectors at each point in X. */
+ for (i=0; i < dnx; i++) {
+ x = x_src[i] - 0.5;
+ px[i] = (int) x;
+ w1[i] = 1.0 - (x - (int)x);
+ w2[i] = 1.0 - w1[i];
+ }
+
+ /* For each line of the destination rect first interpolate in Y to the
+ * y_src coordinate of the output line, then interpolate in X to compute
+ * the final output pixels.
+ */
+ for (j=0; j < dny; j++) {
+ op = odata + (j+dy) * obpl + dx;
+ y = y_src[j] - 0.5;
+ line = (int) y;
+ lo = idata + line * ibpl;
+ hi = idata + min (iny - 1, line + 1) * ibpl;
+ lo_w = 1.0 - (y - line);
+ hi_w = 1.0 - lo_w;
+
+ /* Interpolate in Y to the line at y_src[j]. */
+ for (i=0; i < dnx; i++) {
+ pixel = px[i];
+ lp[i] = (float)lo[pixel] * lo_w + (float)hi[pixel] * hi_w;
+ }
+ lp[-1] = lp[0];
+ lp[dnx] = lp[dnx-1];
+
+ /* Interpolate in X to the final output pixels. */
+ if (!clip_region) {
+ for (i=0; i < dnx; i++)
+ op[i] = lp[i] * w1[i] + lp[i+1] * w2[i];
+ } else {
+ for (i=0; i < dnx; i++)
+ if (XPointInRegion (clip_region, i + dx, j + dy))
+ op[i] = lp[i] * w1[i] + lp[i+1] * w2[i];
+ }
+ }
+
+ XtFree ((char *)buf);
+}
+
+
+/* scale_lowpass -- Apply a lowpass filter to a region of a 2D data array.
+ * The region ox,oy,nx,ny of the output data array is calculated by running
+ * a convolution kernel over the region of the input data array at ix,iy.
+ * The size of the convolution kernel is adjusted to match the scale factors
+ * xscale, yscale.
+ */
+static
+scale_lowpass (idata,inx,iny,ibpl, odata,onx,ony,obpl, x_src,y_src,
+ sx,sy,snx,sny, dx,dy,dnx,dny, xscale,yscale, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* full input array */
+ int onx, ony, obpl; /* full input array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int sx, sy, snx, sny; /* source rect */
+ int dx, dy, dnx, dny; /* destination rect */
+ float xscale, yscale; /* scale factors */
+ Region clip_region; /* clip Region or null */
+{
+ uchar *data;
+
+ if ((data = (uchar *) XtMalloc (inx * iny)) == NULL)
+ return;
+
+ /* Run a lowpass filter over the input rect. */
+ lw_convolve (idata,inx,iny,ibpl, sx,sy, data,inx,iny,ibpl, sx,sy,
+ snx,sny, xscale,yscale);
+
+ /* Sample the filtered data to generate the output rect. */
+ scale_nearest (data,inx,iny,ibpl, odata,onx,ony,obpl, x_src,y_src,
+ dx,dy,dnx,dny, clip_region);
+
+ XtFree ((char *)data);
+}
+
+
+/* lw_convolve -- Convolution primitive for scale_lowpass.
+ */
+static
+lw_convolve (idata,inx,iny,ibpl,ix,iy, odata,onx,ony,obpl,ox,oy,
+ nx, ny, xscale, yscale)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ix, iy; /* size of input array, start pos */
+ int onx, ony, ox, oy; /* size of output array, start pos */
+ int ibpl, obpl; /* bytes per line */
+ int nx, ny; /* size of output region */
+ float xscale, yscale; /* determines amount of smoothing */
+{
+ register uchar *ip;
+ register int l, m, x, hx, pixval;
+ int kx, ky, hy, i, j, y;
+ uchar *lp[11], *op;
+
+ /* Determine kernel size (min 3x3, max 7x7). */
+ if (xscale < 0.1)
+ hx = 3;
+ else if (xscale >= 0.5)
+ hx = 1;
+ else
+ hx = ((int)(1.0 / xscale)) / 2;
+
+ if (yscale < 0.1)
+ hy = 3;
+ else if (yscale >= 0.5)
+ hy = 1;
+ else
+ hy = ((int)(1.0 / yscale)) / 2;
+
+ kx = hx * 2 + 1;
+ ky = hy * 2 + 1;
+
+ /* Compute the output data.
+ */
+ for (j=0; j < ny; j++) {
+ /* Get line pointers. */
+ op = odata + (j+oy) * obpl + ox;
+ for (i=0; i < ky; i++) {
+ y = iy + j - hy + i;
+ if (y < 0)
+ y = 0;
+ else if (y >= iny)
+ y = iny - 1;
+ lp[i] = y * ibpl + idata;
+ }
+
+ /* Compute a line of output pixels */
+ for (i=0; i < nx; i++) {
+ x = ix + i;
+ pixval = 0;
+
+ if (x < hx) {
+ /* Near left edge. */
+ for (m=0; m < ky; m++)
+ for (l=0; l < kx; l++)
+ pixval += lp[m][max(0,x-hx+l)];
+ } else if (x >= inx - hx) {
+ /* Near right edge. */
+ for (m=0; m < ky; m++)
+ for (l=0; l < kx; l++)
+ pixval += lp[m][min(inx-1,x-hx+l)];
+ } else {
+ /* In central region. */
+ for (m=0; m < ky; m++) {
+ ip = lp[m] + x - hx;
+ for (l=0; l < kx; l++)
+ pixval += ip[l];
+ }
+ }
+
+ op[i] = (float)pixval / (float)(kx * ky) + 0.5;
+ }
+ }
+}
+
+
+/* scale_boxcar -- Apply a boxcar filter to a region of a 2D data array
+ * and interpolate the result to the output grid. The region ox,oy,nx,ny of
+ * the output data array is calculated by block averaging the corresponding
+ * source rect and then sampling the reduced image using bilinear interpolation
+ * to compute the output pixel raster. This antialiasing technique aims to
+ * be as fast as possible but still does a reasonable job of reducing the
+ * image.
+ */
+static
+scale_boxcar (idata,inx,iny,ibpl, odata,onx,ony,obpl, x_src,y_src,
+ sx,sy,snx,sny, dx,dy,dnx,dny, xscale,yscale, interp, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* full input array */
+ int onx, ony, obpl; /* full input array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int sx, sy, snx, sny; /* source rect */
+ int dx, dy, dnx, dny; /* destination rect */
+ float xscale, yscale; /* scale factors */
+ int interp; /* set if interpolation is desired */
+ Region clip_region; /* clip Region or null */
+{
+ int xblock, yblock;
+ int x1, x2, y1, y2, nx, ny;
+ float xstep, ystep;
+ int xoff, yoff;
+ uchar *bp;
+
+ /* Determine blocking factors. If interpolation is disabled we need
+ * to block one step more than for the linear interpolate case in order
+ * to ensure that all the data is used.
+ */
+ xblock = max(1, (int) (1.0 / xscale));
+ if (!interp && (1.0 / xscale) - xblock > ZOOM_TOL)
+ xblock++;
+ yblock = max(1, (int) (1.0 / yscale));
+ if (!interp && (1.0 / yscale) - yblock > ZOOM_TOL)
+ yblock++;
+
+ /* Align the input region for the given blocking factors. */
+ x1 = sx / xblock * xblock; x2 = (sx + snx - 1) / xblock * xblock;
+ y1 = sy / yblock * yblock; y2 = (sy + sny - 1) / yblock * yblock;
+ nx = (x2 - x1) / xblock + 1; ny = (y2 - y1) / yblock + 1;
+
+ /* Compute the block averaged input rect. */
+ if (xblock > 1 || yblock > 1) {
+ if ((bp = (uchar *) XtMalloc (nx * ny)) == NULL)
+ return;
+ bx_boxcar (idata,inx,iny,ibpl, x1,y1,x2,y2, bp, xblock, yblock);
+ idata = bp;
+ inx = ibpl = nx;
+ iny = ny;
+ xoff = x1; yoff = y1;
+ xstep = 1.0 / xblock; ystep = 1.0 / yblock;
+ } else {
+ bp = NULL;
+ xoff = yoff = 0;
+ xstep = ystep = 1.0;
+ }
+
+ /* Interpolate the input rect to the output grid. */
+ if (interp &&
+ ((1.0 / xscale) - xblock) > ZOOM_TOL ||
+ ((1.0 / yscale) - yblock) > ZOOM_TOL) {
+
+ /* Use bilinear interpolation to compute the output grid. */
+ bx_interp (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, xoff,yoff,xstep,ystep, dx,dy,dnx,dny, clip_region);
+
+ } else {
+ /* Extract pixels from block averaged input data. */
+ bx_extract (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, xoff,yoff,xstep,ystep, dx,dy,dnx,dny, clip_region);
+ }
+
+ if (bp)
+ XtFree ((char *)bp);
+}
+
+
+/* bx_boxcar -- Block average primitive for scale_boxcar.
+ */
+static
+bx_boxcar (idata,inx,iny,ibpl, x1,y1,x2,y2, obuf, xblock, yblock)
+ uchar *idata; /* input data array */
+ int inx, iny, ibpl; /* array dimensions */
+ int x1,y1,x2,y2; /* region to be block averaged */
+ uchar *obuf; /* output array */
+ int xblock, yblock; /* blocking factors */
+{
+ register uchar *ip, *op;
+ register int count, i, *sp;
+ int obpl, block, nxblocks, nyblocks, j, k;
+ uchar *lp, *bp;
+ int *sb;
+
+ nxblocks = obpl = (x2 - x1) / xblock + 1;
+ nyblocks = (y2 - y1) / yblock + 1;
+ count = xblock * yblock;
+
+ if ((sb = (int *) XtMalloc (obpl * sizeof(int))) == NULL)
+ return;
+
+ /* I don't think the following works for pixel values allocated from the
+ * default colormap, as the pixel values are not sequentially allocated.
+ */
+ for (block = 0; block < nyblocks; block++) {
+ lp = idata + ibpl * (block * yblock + y1) + x1;
+ bp = obuf + block * obpl;
+
+ memset (sb, 0, obpl * sizeof(int));
+ for (k=yblock; --k >= 0; lp += ibpl)
+ for (j=nxblocks, ip=lp, sp=sb; --j >= 0; sp++)
+ for (i=xblock; --i >= 0; )
+ *sp += *ip++;
+
+ for (i=obpl, sp=sb, op=bp; --i >= 0; )
+ *op++ = *sp++ / count;
+ }
+
+ XtFree ((char *)sb);
+}
+
+
+/* bx_extract -- Block extract primitive for scale_boxcar.
+ */
+static
+bx_extract (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, xoff,yoff,xstep,ystep, dx,dy,dnx,dny, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* full input array */
+ int onx, ony, obpl; /* full input array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int dx, dy, dnx, dny; /* destination rect */
+ int xoff, yoff; /* offset of input region */
+ float xstep, ystep; /* scale of input region */
+ Region clip_region; /* clip Region or null */
+{
+ register int m, n, i;
+ register uchar *op;
+ int j;
+
+ for (j=0; j < dny; j++) {
+ op = odata + (j+dy) * obpl + dx;
+ n = (y_src[j] - yoff) * ystep;
+
+ if (!clip_region) {
+ for (i=0; i < dnx; i++) {
+ m = (x_src[i] - xoff) * xstep;
+ op[i] = idata[n * ibpl + m];
+ }
+ } else {
+ for (i=0; i < dnx; i++)
+ if (XPointInRegion (clip_region, i + dx, j + dy)) {
+ m = (x_src[i] - xoff) * xstep;
+ op[i] = idata[n * ibpl + m];
+ }
+ }
+ }
+}
+
+
+/* bx_interp -- Bilinear interpolation primitive for scale_boxcar.
+ */
+static
+bx_interp (idata,inx,iny,ibpl, odata,onx,ony,obpl,
+ x_src,y_src, xoff,yoff,xstep,ystep, dx,dy,dnx,dny, clip_region)
+
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* dimensions of input array */
+ int onx, ony, obpl; /* dimensions of output array */
+ float *x_src, *y_src; /* src coords of each dst pixel */
+ int xoff, yoff; /* offset of input region */
+ float xstep, ystep; /* scale of input region */
+ int dx, dy, dnx, dny; /* destination rect */
+ Region clip_region; /* clip Region or null */
+{
+ register int i;
+ register uchar *op;
+ register float *lp, *w1, *w2;
+ int buflen, line, *px, pixel, j;
+ float lo_w, hi_w, x, y;
+ uchar *lo, *hi;
+ float *buf;
+
+ buflen = (3 * dnx + 2) * sizeof(float) + dnx * sizeof(int);
+ if ((buf = (float *) XtMalloc (buflen)) == NULL)
+ return;
+
+ lp = buf + 1;
+ w1 = lp + dnx + 1;
+ w2 = w1 + dnx;
+ px = (int *)(w2 + dnx);
+
+ /* Compute the weight vectors at each point in X. */
+ for (i=0; i < dnx; i++) {
+ x = ((x_src[i] - xoff) * xstep) - 0.5;
+ px[i] = (int) x;
+ w1[i] = 1.0 - (x - (int)x);
+ w2[i] = 1.0 - w1[i];
+ }
+
+ /* For each line of the destination rect first interpolate in Y to the
+ * y_src coordinate of the output line, then interpolate in X to compute
+ * the final output pixels.
+ */
+ for (j=0; j < dny; j++) {
+ op = odata + (j+dy) * obpl + dx;
+ y = ((y_src[j] - yoff) * ystep) - 0.5;
+ line = (int) y;
+ lo = idata + line * ibpl;
+ hi = idata + min (iny - 1, line + 1) * ibpl;
+ lo_w = 1.0 - (y - line);
+ hi_w = 1.0 - lo_w;
+
+ /* Interpolate in Y to the line at y_src[j]. */
+ for (i=0; i < dnx; i++) {
+ pixel = px[i];
+ lp[i] = (float)lo[pixel] * lo_w + (float)hi[pixel] * hi_w;
+ }
+ lp[-1] = lp[0];
+ lp[dnx] = lp[dnx-1];
+
+ /* Interpolate in X to the final output pixels. */
+ if (!clip_region) {
+ for (i=0; i < dnx; i++)
+ op[i] = lp[i] * w1[i] + lp[i+1] * w2[i];
+ } else {
+ for (i=0; i < dnx; i++)
+ if (XPointInRegion (clip_region, i + dx, j + dy))
+ op[i] = lp[i] * w1[i] + lp[i+1] * w2[i];
+ }
+ }
+
+ XtFree ((char *)buf);
+}
+
+
+/* mf_getinten -- Copy the source rect to the destination rect, converting
+ * pixel numbers to pixel intensities.
+ */
+static
+mf_getinten (w, idata,inx,iny,ibpl, sx,sy, odata,onx,ony,obpl, dx,dy, nx,ny)
+
+ GtermWidget w;
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* dimensions of input array */
+ int onx, ony, obpl; /* dimensions of output array */
+ int sx, sy; /* source offset */
+ int dx, dy; /* destination offset */
+ int nx, ny; /* size of region */
+{
+ register Pixel *cmap;
+ register uchar *ip, *op;
+ register int n;
+ int j;
+
+ cmap = get_cmap_out (w);
+ for (j=0; j < ny; j++) {
+ ip = idata + ibpl * (sy + j) + sx;
+ op = odata + obpl * (dy + j) + dx;
+ for (n = nx; --n >= 0; )
+ *op++ = (cmap[*ip++]);
+ }
+}
+
+
+/* mf_getpixel -- Copy the source rect to the destination rect, converting
+ * pixel intensities to pixel numbers.
+ */
+static
+mf_getpixel (w, idata,inx,iny,ibpl, sx,sy, odata,onx,ony,obpl, dx,dy, nx,ny)
+
+ GtermWidget w;
+ uchar *idata, *odata; /* input, output data */
+ int inx, iny, ibpl; /* dimensions of input array */
+ int onx, ony, obpl; /* dimensions of output array */
+ int sx, sy; /* source offset */
+ int dx, dy; /* destination offset */
+ int nx, ny; /* size of region */
+{
+ register Pixel *cmap;
+ register uchar *ip, *op;
+ register int n;
+ int j;
+
+ cmap = get_cmap_in (w);
+ for (j=0; j < ny; j++) {
+ ip = idata + ibpl * (sy + j) + sx;
+ op = odata + obpl * (dy + j) + dx;
+ for (n = nx; --n >= 0; )
+ *op++ = (cmap[*ip++]);
+ }
+}
+
+
+/* get_regions -- For each pixel I in the sequence of DNX pixels starting at DX
+ * there is an associated value XMAP[I]. Compare this sequence to an alternate
+ * sequence and return a list of subregions {XS,XE,XV} for which the XMAP
+ * values are equal (XV=0), not equal (XV=1), or not common to (XV=2) the two
+ * regions. The number of regions output is returned as the function value.
+ */
+static
+get_regions (xs,xe,xv, max_regions, dx, dnx, xmap, alt_dx, alt_dnx, alt_xmap)
+ int *xs, *xe, *xv, max_regions;
+ int dx, dnx, *xmap;
+ int alt_dx, alt_dnx, *alt_xmap;
+{
+ register int state, current;
+ register int nx, i;
+ int offset, old_i;
+
+ offset = dx - alt_dx;
+ nx = 0;
+
+ for (i=0; i < dnx; i++) {
+ if (nx >= max_regions-1)
+ return (0);
+
+ /* Determine whether or not this pixel is mapped the same in both
+ * sequences.
+ */
+ old_i = i + offset;
+ if (alt_dnx <= 0 || old_i < 0 || old_i >= alt_dnx)
+ state = 2;
+ else
+ state = (xmap[i] != alt_xmap[old_i]);
+
+ /* When the state boundary is crossed add a range. */
+ if (i == 0) {
+ xs[nx] = dx;
+ xv[nx] = current = state;
+ }
+ if (state != current) {
+ xe[nx] = dx + i - 1;
+ xs[++nx] = dx + i;
+ xv[nx] = current = state;
+ }
+ if (i == dnx-1)
+ xe[nx++] = dx + i;
+ }
+
+ return (nx);
+}
+
+
+/* get_rects -- Combine two lists of regions, one in X and the other in Y,
+ * to produce a list of 2D rectangles defining the regions outlined by the
+ * region lists. Only rects for which the given condition is true in either
+ * X or Y are selected. Adjacent rects are combined.
+ */
+static
+get_rects (o_rl, max_rects, xs,xe,xv,nx, ys,ye,yv,ny, xcond,ycond)
+ XRectangle *o_rl; /* receives list of rectangles */
+ int max_rects; /* max rectangles out */
+ int *xs, *xe, *xv, nx; /* X list of regions */
+ int *ys, *ye, *yv, ny; /* Y list of regions */
+ int xcond, ycond; /* X,Y condition bitflags */
+{
+ register int i, j;
+ XRectangle rl[MAX_REGIONS];
+ int limit = min (max_rects, MAX_REGIONS);
+ int o_nrects=0, nrects=0;
+ int i1, i2, j1, j2;
+
+ /* Get initial list of rects matching the given X and Y conditions.
+ * Rects which are adjacent in X are combined to form one larger rect.
+ */
+ for (j=0; j < ny; j++) {
+ for (i=0; i < nx; i++) {
+ if ((xv[i] & xcond) || (yv[j] & ycond)) {
+ /* Collapse rects adjacent in X. */
+ for (i1 = i2 = i++; i < nx; i++) {
+ if ((xv[i] & xcond) || (yv[j] & ycond))
+ i2 = i;
+ else
+ break;
+ }
+
+ rl[nrects].x = xs[i1];
+ rl[nrects].y = ys[j];
+ rl[nrects].width = xe[i2] - xs[i1] + 1;
+ rl[nrects].height = ye[j] - ys[j] + 1;
+
+ if (++nrects >= limit)
+ return (nrects);
+ }
+ }
+ }
+
+ /* Now scan the rect list and collapse rects which are adjacent in Y
+ * into one larger rect. Find all the rects that are at the same X
+ * and write them to the output list, collapsing rects that are adjacent
+ * in Y in the process.
+ */
+ for (i=0; i < nx; i++)
+ for (j=0; j < nrects; ) {
+ /* Find first rect if any. */
+ for (j1=0, j2 = -1; j < nrects; j++)
+ if (rl[j].x == xs[i]) {
+ j1 = j2 = j++;
+ break;
+ }
+
+ /* Collapse rects adjacent in Y. */
+ for ( ; j < nrects; j++)
+ if (rl[j].x == xs[i])
+ if (rl[j].y == rl[j2].y + rl[j2].height &&
+ rl[j].width == rl[j1].width)
+ j2 = j;
+ else
+ break;
+
+ /* Output the rect. */
+ if (j2 >= j1) {
+ o_rl[o_nrects].x = rl[j1].x;
+ o_rl[o_nrects].y = rl[j1].y;
+ o_rl[o_nrects].width = rl[j1].width;
+ o_rl[o_nrects].height = rl[j2].y + rl[j2].height - rl[j1].y;
+
+ if (++o_nrects >= max_rects)
+ return (o_nrects);
+ }
+ }
+
+ return (o_nrects);
+}
+
+
+/* rect_intersect -- Compute the intersection of two rects. The area of
+ * the intersection is returned as the function value, i.e., zero is
+ * returned if the rects do not intersect.
+ */
+static
+rect_intersect (in, r1, r2)
+ register XRectangle *in;
+ register XRectangle *r1, *r2;
+{
+ int x1, y1, x2, y2;
+
+ x1 = max (r1->x, r2->x);
+ y1 = max (r1->y, r2->y);
+ x2 = min ((int)r1->x + (int)r1->width, (int)r2->x + (int)r2->width) - 1;
+ y2 = min ((int)r1->y + (int)r1->height, (int)r2->y + (int)r2->height) - 1;
+
+ in->x = x1;
+ in->y = y1;
+ in->width = max (0, x2 - x1 + 1);
+ in->height = max (0, y2 - y1 + 1);
+
+ return (in->width * in->height);
+}
+
+
+/* save_mapping -- Store a mapping in a mapping descriptor.
+ */
+static
+save_mapping (mp, mapping, rop, src, st, sx,sy,sw,sh, dst, dt, dx,dy,dw,dh)
+ register Mapping mp;
+ int mapping, rop;
+ int src, st, sx,sy,sw,sh;
+ int dst, dt, dx,dy,dw,dh;
+{
+ mp->src = src; mp->st = st;
+ mp->sx = sx; mp->sy = sy; mp->snx = sw; mp->sny = sh;
+ mp->dst = dst; mp->dt = dt;
+ mp->dx = dx; mp->dy = dy; mp->dnx = dw; mp->dny = dh;
+ mp->defined = mp->enabled = mp->refresh = 1;
+ mp->mapping = mapping;
+ mp->rop = rop;
+}
+
+/* load_mapping -- Load a mapping from a mapping descriptor.
+ */
+static
+load_mapping (mp, mapping, rop, src, st, sx,sy,sw,sh, dst, dt, dx,dy,dw,dh)
+ register Mapping mp;
+ int *mapping, *rop;
+ int *src, *st, *sx,*sy,*sw,*sh;
+ int *dst, *dt, *dx,*dy,*dw,*dh;
+{
+ *src = mp->src; *st = mp->st;
+ *sx = mp->sx; *sy = mp->sy; *sw = mp->snx; *sh = mp->sny;
+ *dst = mp->dst; *dt = mp->dt;
+ *dx = mp->dx; *dy = mp->dy; *dw = mp->dnx; *dh = mp->dny;
+ *mapping = mp->mapping;
+ *rop = mp->rop;
+}
+
+
+/* get_pixel_mapping -- Copy a mapping, converting to pixel coordinates in
+ * the process if the mapping is not already in pixel coordinates.
+ */
+static
+get_pixel_mapping (w, mp1, mp2, update)
+ GtermWidget w;
+ register Mapping mp1; /* input mapping */
+ register Mapping mp2; /* output mapping */
+ int update; /* update mapping */
+{
+ float maxndc = (float)MAXNDC;
+
+ mp2->mapping = mp1->mapping;
+ mp2->refresh = mp1->refresh;
+ mp2->enabled = mp1->enabled;
+ mp2->rop = mp1->rop;
+
+ if (!(mp2->defined = mp1->defined))
+ return;
+
+ mp2->src = mp1->src;
+ if (mp1->st == GtPixel) {
+ mp2->st = mp1->st;
+ mp2->sx = mp1->sx; mp2->sy = mp1->sy;
+ mp2->snx = mp1->snx; mp2->sny = mp1->sny;
+ } else {
+ float width = w->gterm.rasters[mp1->src].width;
+ float height = w->gterm.rasters[mp1->src].height;
+ mp2->sx = mp1->sx * width / maxndc;
+ mp2->sy = (MAXNDC - (mp1->sy + abs(mp1->sny))) * height / maxndc;
+ mp2->snx = mp1->snx * width / maxndc;
+ mp2->sny = mp1->sny * height / maxndc; /* NDC flipped in Y */
+ mp2->st = GtPixel;
+ }
+
+ mp2->dst = mp1->dst;
+ if (mp1->dt == GtPixel) {
+ mp2->dt = mp1->dt;
+ mp2->dx = mp1->dx; mp2->dy = mp1->dy;
+ mp2->dnx = mp1->dnx; mp2->dny = mp1->dny;
+ } else {
+ float width = w->gterm.rasters[mp1->dst].width;
+ float height = w->gterm.rasters[mp1->dst].height;
+ mp2->dx = mp1->dx * width / maxndc;
+ mp2->dy = (MAXNDC - (mp1->dy + abs(mp1->dny))) * height / maxndc;
+ mp2->dnx = mp1->dnx * width / maxndc;
+ mp2->dny = mp1->dny * -height / maxndc; /* NDC flipped in Y */
+ mp2->dt = GtPixel;
+ }
+
+ /* The lookup tables are already in pixel space, so we can propagate
+ * these to the new mapping if the old mapping was updated.
+ */
+ if (update && mp1->updated) {
+ if (mp2->mapdata = (uchar *) XtMalloc (mp1->datalen)) {
+
+ memmove (mp2->mapdata, mp1->mapdata, mp1->datalen);
+ mp2->datalen = mp1->datalen;
+ mp2->scaling = mp1->scaling;
+ mp2->xscale = mp1->xscale;
+ mp2->yscale = mp1->yscale;
+
+ mp2->x_extent = (mapExtent *)
+ ((uchar *)mp1->x_extent - mp1->mapdata + mp2->mapdata);
+ mp2->y_extent = (mapExtent *)
+ ((uchar *)mp1->y_extent - mp1->mapdata + mp2->mapdata);
+ mp2->x_srcpix = (int *)
+ ((uchar *)mp1->x_srcpix - mp1->mapdata + mp2->mapdata);
+ mp2->y_srcpix = (int *)
+ ((uchar *)mp1->y_srcpix - mp1->mapdata + mp2->mapdata);
+ mp2->x_src = (float *)
+ ((uchar *)mp1->x_src - mp1->mapdata + mp2->mapdata);
+ mp2->y_src = (float *)
+ ((uchar *)mp1->y_src - mp1->mapdata + mp2->mapdata);
+
+ mp2->updated = 1;
+ }
+ } else
+ mp2->updated = 0;
+}
+
+/* valid_mapping -- Perform some sanity checks on a mapping to verify that
+ * it contains something meaningful.
+ */
+static
+valid_mapping (w, mp)
+ GtermWidget w;
+ register Mapping mp;
+{
+ register int x, y;
+ int snx, sny, dnx, dny;
+ int s_width, s_height, d_width, d_height;
+ Raster sr, dr;
+
+ if (!mp || !mp->defined)
+ return (False);
+
+ if (mp->src < 0 || mp->src >= w->gterm.maxRasters)
+ return (False);
+ if (mp->dst < 0 || mp->dst >= w->gterm.maxRasters)
+ return (False);
+
+ sr = &w->gterm.rasters[mp->src];
+ dr = &w->gterm.rasters[mp->dst];
+ if (!sr->type || !dr->type)
+ return (False);
+
+ switch (mp->st) {
+ case GtPixel:
+ s_width = sr->width; s_height = sr->height;
+ break;
+ case GtNDC:
+ s_width = MAXNDC + 1; s_height = MAXNDC + 1;
+ break;
+ default:
+ return (False);
+ }
+
+ switch (mp->dt) {
+ case GtPixel:
+ d_width = dr->width; d_height = dr->height;
+ break;
+ case GtNDC:
+ d_width = MAXNDC + 1; d_height = MAXNDC + 1;
+ break;
+ default:
+ return (False);
+ }
+
+ snx = mp->snx; dnx = abs(mp->dnx);
+ sny = mp->sny; dny = abs(mp->dny);
+ if (snx <= 0 || dnx <= 0 || sny <= 0 || dny <= 0)
+ return (False);
+
+ x = mp->sx; y = mp->sy;
+ if (x < 0 || x >= s_width || y < 0 || y >= s_height)
+ return (False);
+ x = mp->sx + snx - 1; y = mp->sy + sny - 1;
+ if (x < 0 || x >= s_width || y < 0 || y >= s_height)
+ return (False);
+
+ x = mp->dx; y = mp->dy;
+ if (x < 0 || x >= d_width || y < 0 || y >= d_height)
+ return (False);
+ x = mp->dx + dnx - 1; y = mp->dy + dny - 1;
+ if (x < 0 || x >= d_width || y < 0 || y >= d_height)
+ return (False);
+
+ return (True);
+}
+
+
+/* initialize_mapping -- Initialize the contents of a mapping descriptor.
+ */
+static
+initialize_mapping (mp)
+ register Mapping mp;
+{
+ memset ((char *)mp, 0, sizeof(struct mapping));
+}
+
+
+/* update_mapping -- Update the portion of a mapping descriptor used at
+ * runtime to execute the mapping. This information consists of several
+ * lookup tables and other parameters describing how a destination pixel
+ * maps back to a source pixel and vice versa.
+ */
+static
+update_mapping (w, mp)
+ GtermWidget w;
+ register Mapping mp;
+{
+ register uchar *op;
+ register int i, j, k;
+ int snx, sny, dnx, dny, sx, sy, dx, dy;
+ int xmax, ymax, lo, hi, edge1, edge2;
+ int temp, xflip=0, yflip=0;
+ struct mapping p_mp;
+ float pixwidth, *fp;
+ int *ip;
+
+ if (mp->updated)
+ return;
+
+ /* The internal lookup tables are in pixel units. */
+ initialize_mapping (&p_mp);
+ get_pixel_mapping (w, mp, &p_mp, 0);
+
+ if ((snx = p_mp.snx) <= 0 || (sny = p_mp.sny) <= 0)
+ return;
+
+ if ((dnx = p_mp.dnx) < 0) {
+ dnx = -dnx;
+ xflip++;
+ }
+ if ((dny = p_mp.dny) < 0) {
+ dny = -dny;
+ yflip++;
+ }
+
+ sx = p_mp.sx;
+ sy = p_mp.sy;
+ dx = p_mp.dx;
+ dy = p_mp.dy;
+ xmax = dnx - 1;
+ ymax = dny - 1;
+
+ /* Discard the temporary mapping.
+ free_mapping (w, &p_mp);
+ */
+
+ /* Get scale factors. */
+ mp->xscale = (float)dnx / (float)snx;
+ mp->yscale = (float)dny / (float)sny;
+
+ /* Determine type of scaling to be used. */
+ if (mp->xscale < 1.0 || mp->yscale < 1.0) {
+ mp->scaling = M_DEZOOM;
+ } else if (mp->xscale > 1.0 || mp->yscale > 1.0) {
+ mp->scaling = M_ZOOM;
+ if (abs(mp->xscale - (int)(mp->xscale+0.5)) < ZOOM_TOL &&
+ abs(mp->yscale - (int)(mp->yscale+0.5)) < ZOOM_TOL)
+ mp->scaling = M_INTZOOM;
+ } else
+ mp->scaling = (xflip || yflip) ? M_ZOOM : M_NOSCALING;
+
+ /* Get a data buffer for the lookup tables. */
+ mp->datalen =
+ snx * sizeof(mapExtent) + /* xy, extent */
+ sny * sizeof(mapExtent) +
+ dnx * sizeof(int) + /* xy, srcpix */
+ dny * sizeof(int) +
+ dnx * sizeof(float) + /* xy, src */
+ dny * sizeof(float);
+
+ if (mp->mapdata)
+ mp->mapdata = (uchar *) XtRealloc ((char *)mp->mapdata, mp->datalen);
+ else
+ mp->mapdata = (uchar *) XtMalloc (mp->datalen);
+ if (mp->mapdata == NULL)
+ return;
+
+ /* Set the table pointers. */
+ op = mp->mapdata;
+ mp->x_extent = (mapExtent *) op; op += snx * sizeof(mapExtent);
+ mp->y_extent = (mapExtent *) op; op += sny * sizeof(mapExtent);
+ mp->x_srcpix = (int *) op; op += dnx * sizeof(int);
+ mp->y_srcpix = (int *) op; op += dny * sizeof(int);
+ mp->x_src = (float *) op; op += dnx * sizeof(float);
+ mp->y_src = (float *) op; op += dny * sizeof(float);
+
+ /* Compute the backpointers to the source raster for each destination
+ * pixel center.
+ */
+ for (i=0, ip = mp->x_srcpix, fp = mp->x_src; i < dnx; i++) {
+ fp[i] = ((xflip ? xmax - i : i) + 0.5) / mp->xscale + sx;
+ ip[i] = fp[i];
+ }
+ for (i=0, ip = mp->y_srcpix, fp = mp->y_src; i < dny; i++) {
+ fp[i] = ((yflip ? ymax - i : i) + 0.5) / mp->yscale + sy;
+ ip[i] = fp[i];
+ }
+
+ /* Compute the extent arrays. These define the range of destination
+ * pixels affected by each source pixel.
+ */
+ lo = dnx - 1 + dx;
+ hi = dx;
+ for (i=0; i < snx; i++) {
+ mp->x_extent[i].lo = lo;
+ mp->x_extent[i].hi = hi;
+ }
+ lo = dny - 1 + dy;
+ hi = dy;
+ for (i=0; i < sny; i++) {
+ mp->y_extent[i].lo = lo;
+ mp->y_extent[i].hi = hi;
+ }
+
+ /* Map the left and right or top and bottom edges of each destination
+ * pixel back into the source rect and update the corresponding extent
+ * entries to indicate that these source pixels are used to compute the
+ * destination pixel.
+ */
+ pixwidth = 1.0 - ZOOM_TOL;
+
+ for (i=0; i < dnx; i++) {
+ edge1 = (xflip ? xmax - i : i) / mp->xscale;
+ edge2 = (xflip ? xmax - (i-pixwidth) : (i+pixwidth)) / mp->xscale;
+ if (edge1 > edge2) {
+ temp = edge1; edge1 = edge2; edge2 = temp;
+ }
+ edge1 = max (0, edge1);
+ edge2 = min (snx - 1, edge2);
+
+ for (j=edge1, k = dx + i; j <= edge2; j++) {
+ if (mp->x_extent[j].lo > k)
+ mp->x_extent[j].lo = k;
+ if (mp->x_extent[j].hi < k)
+ mp->x_extent[j].hi = k;
+ }
+ }
+
+ for (i=0; i < dny; i++) {
+ edge1 = (yflip ? ymax - i : i) / mp->yscale;
+ edge2 = (yflip ? ymax - (i-pixwidth) : (i+pixwidth)) / mp->yscale;
+ if (edge1 > edge2) {
+ temp = edge1; edge1 = edge2; edge2 = temp;
+ }
+ edge1 = max (0, edge1);
+ edge2 = min (sny - 1, edge2);
+
+ for (j=edge1, k = dy + i; j <= edge2; j++) {
+ if (mp->y_extent[j].lo > k)
+ mp->y_extent[j].lo = k;
+ if (mp->y_extent[j].hi < k)
+ mp->y_extent[j].hi = k;
+ }
+ }
+
+ mp->updated = 1;
+}
+
+
+/* free_mapping -- Free any storage used internally by a mapping descriptor,
+ * and deactivate the mapping.
+ */
+static
+free_mapping (w, mp)
+ GtermWidget w;
+ register Mapping mp;
+{
+ mp_unlink (w, mp);
+ mp->defined = mp->enabled = mp->updated = 0;
+ if (mp->mapdata) {
+ XtFree ((char *) mp->mapdata);
+ mp->mapdata = NULL;
+ mp->datalen = 0;
+ mp->x_extent = mp->y_extent = NULL;
+ mp->x_srcpix = mp->y_srcpix = NULL;
+ mp->x_src = mp->y_src = NULL;
+ mp->updated = 0;
+ }
+}
+
+static void
+mp_linkafter (w, mp, ref_mp)
+ register GtermWidget w;
+ register Mapping mp;
+ register Mapping ref_mp;
+{
+ register Mapping map;
+
+ /* Don't use the reference mapping unless it is already linked or
+ * the list is empty.
+ */
+ if (w->gterm.mp_head) {
+ for (map = w->gterm.mp_head; map && map != ref_mp; map = map->next)
+ ;
+ if (map != ref_mp)
+ ref_mp = NULL;
+ }
+
+ mp->prev = ref_mp;
+ mp->next = ref_mp ? ref_mp->next : NULL;
+ if (ref_mp && ref_mp->next)
+ ref_mp->next->prev = mp;
+ if (ref_mp)
+ ref_mp->next = mp;
+
+ if (!w->gterm.mp_tail || ref_mp == w->gterm.mp_tail)
+ w->gterm.mp_tail = mp;
+ if (!w->gterm.mp_head)
+ w->gterm.mp_head = mp;
+}
+
+
+static void
+mp_unlink (w, mp)
+ register GtermWidget w;
+ register Mapping mp;
+{
+ if (mp->prev)
+ mp->prev->next = mp->next;
+ if (mp->next)
+ mp->next->prev = mp->prev;
+ if (w->gterm.mp_head == mp)
+ w->gterm.mp_head = mp->next;
+ if (w->gterm.mp_tail == mp)
+ w->gterm.mp_tail = mp->prev;
+
+ mp->prev = mp->next = NULL;
+}
+
+
+
generated by cgit (git 2.34.1) at 2025-09-20 14:28:50 -0400