home *** CD-ROM | disk | FTP | other *** search
/ vis-ftp.cs.umass.edu / vis-ftp.cs.umass.edu.tar / vis-ftp.cs.umass.edu / pub / Software / universal_plane_file_format / NewXShowPlane / Xshpl.c < prev   
C/C++ Source or Header  |  1993-12-06  |  10KB  |  313 lines
  1. /*
  2.  * ------------------------------------------------------------------
  3.  * Xshpl.c - show plane guts
  4.  * Created by Robert Heller on Fri Dec  3 10:24:55 1993
  5.  * ------------------------------------------------------------------
  6.  * Modification History:
  7.  * ------------------------------------------------------------------
  8.  * Contents:
  9.  * ------------------------------------------------------------------
  10.  *  
  11.  * 
  12.  *            Copyright 1993 University of Massachusetts.
  13.  *                          All rights reserved.
  14.  * 
  15.  *      Permission to copy and modify this software and its documen-
  16.  *      tation only for internal use in your organization is hereby
  17.  *      granted, provided that this notice is retained thereon and
  18.  *      on all copies.  UMASS makes no representations as to the sui-
  19.  *      tability and operability of this software for any purpose.
  20.  *      It is provided "as is" without express or implied warranty.
  21.  * 
  22.  *      UMASS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  23.  *      INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
  24.  *      NESS.  IN NO EVENT SHALL UMASS BE LIABLE FOR ANY SPECIAL,
  25.  *      INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY OTHER DAMAGES WHAT-
  26.  *      SOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  27.  *      IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  28.  *      ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PER-
  29.  *      FORMANCE OF THIS SOFTWARE.
  30.  * 
  31.  *      No other rights, including, for example, the right to redis-
  32.  *      tribute this software and its documentation or the right to
  33.  *      prepare derivative works, are granted unless specifically
  34.  *      provided in a separate license agreement.
  35.  * 
  36.  *      Copyright 1993, University of Massachusetts. All rights
  37.  *      reserved.
  38.  * 
  39.  * 
  40.  */
  41.  
  42. #include <stdio.h>
  43. #include <math.h>
  44. #include <X11/Intrinsic.h>
  45. #include "llvs_per_plane.h"
  46.  
  47. #define autoscale ((minval == 0.0) && (maxval == 0.0))
  48.  
  49. static plane_min_max(plane,plane_info,limits,minval,maxval)
  50. PLANE *plane;
  51. PLANE_INFO *plane_info;
  52. LIMITS *limits;
  53. double *minval, *maxval;
  54. {
  55.     int runlevel;
  56.     int deltapllevel;
  57.     int roff,coff;
  58.     int crow,ccol;
  59.     int flag;
  60.     double pixel,fback;
  61.     
  62.     runlevel = limits->level;
  63.  
  64.     if (plane_info->datatype == FLOAT) fback = plane_info->background.flonum;
  65.     else fback = plane_info->background.fixnum;
  66.  
  67.     deltapllevel = runlevel - plane_info->level;
  68.  
  69.     flag = TRUE;
  70.  
  71.     for (crow = limits->startrow;
  72.          crow <= limits->endrow;
  73.          crow += limits->deltarow)
  74.     {
  75.  
  76.         TRANSLEVEL(roff,crow,deltapllevel,plane_info->row_location);
  77.  
  78.         for (ccol = limits->startcol;
  79.              ccol <= limits->endcol;
  80.              ccol += limits->deltacol)
  81.         {
  82.  
  83.             TRANSLEVEL(coff,ccol,deltapllevel,plane_info->column_location);
  84.     
  85.             GET_PIXEL(pixel,fback,plane,roff,coff,
  86.                         (*plane_info));
  87.  
  88.             if (flag)
  89.             {
  90.                 *minval = pixel;
  91.             *maxval = pixel;
  92.             flag = FALSE;
  93.             } else if (pixel > *maxval) *maxval = pixel;
  94.             else if (pixel < *minval) *minval = pixel;
  95.         }
  96.     }
  97. }
  98.  
  99. XShpl_grey(PLANE *plane,PLANE_INFO *plane_info,LIMITS *limits,
  100.        double minval,double maxval,int pixelsize,
  101.        int absolute,int negative,XImage *ximage,
  102.        Pixel *pixel_mapping,int number_grey)
  103. {
  104.     int i, ipixel;
  105.     int runlevel;
  106.     int deltapllevel;
  107.     int roff,coff;
  108.     int xim_y_coord, xim_x_coord;
  109.     int crow,ccol;
  110.     int byte, ipixrow, ipixcol;
  111.     double intensity_scale,value_range,pixel,scaled_pixel,fback;
  112.  
  113.     if (autoscale) plane_min_max(plane,plane_info,limits,&minval,&maxval);
  114.     
  115.     runlevel = limits->level;
  116.  
  117.     if (plane_info->datatype == FLOAT) fback = plane_info->background.flonum;
  118.     else fback = plane_info->background.fixnum;
  119.  
  120.     deltapllevel = runlevel - plane_info->level;
  121.     value_range = maxval - minval;
  122.     intensity_scale = ((double) (number_grey - 1)) / value_range;
  123.  
  124.     for (crow = limits->startrow;
  125.          crow <= limits->endrow;
  126.          crow += limits->deltarow) {
  127.  
  128.         TRANSLEVEL(roff,crow,deltapllevel,plane_info->row_location);
  129.         xim_y_coord = (crow - limits->startrow) * pixelsize;
  130.  
  131.         for (ccol = limits->startcol;
  132.              ccol <= limits->endcol;
  133.              ccol += limits->deltacol) {
  134.  
  135.             TRANSLEVEL(coff,ccol,deltapllevel,plane_info->column_location);
  136.             xim_x_coord = (ccol - limits->startcol) * pixelsize;
  137.     
  138.             GET_PIXEL(pixel,fback,plane,roff,coff,
  139.                         (*plane_info));
  140.             if (absolute) pixel = fabs(pixel);
  141.         /* scale pixel.  out of range values get black or white.
  142.            otherwise linear mapping */
  143.             if (intensity_scale > 0.0) {
  144.             /* positive slope case */
  145.             if (pixel < minval)
  146.                 scaled_pixel = 0.0;
  147.             else
  148.                 if (pixel > maxval)
  149.                 scaled_pixel = number_grey-1;
  150.                 else
  151.                 scaled_pixel =(pixel - minval) *
  152.                     intensity_scale;
  153.             } else {    /* negative slope case */
  154.             if (pixel < maxval)
  155.                 scaled_pixel = number_grey-1;
  156.             else
  157.                 if (pixel > minval)
  158.                 scaled_pixel = 0.0;
  159.                 else
  160.                 scaled_pixel =(pixel - minval) *
  161.                     intensity_scale;
  162.             }
  163.             byte = scaled_pixel + 0.5;
  164.             if (negative) byte = (number_grey-1) - byte;
  165.             for (ipixrow = 0; ipixrow < pixelsize; ipixrow++) {
  166.                 for (ipixcol = 0; ipixcol < pixelsize; ipixcol++) {
  167.                 XPutPixel(ximage,xim_x_coord+ipixcol,
  168.                       xim_y_coord+ipixrow,pixel_mapping[byte]);
  169.             }
  170.             }
  171.              }
  172.     }
  173.     
  174. }
  175.  
  176. /* maximum device intensity.  these values are typical for 8 bits/color
  177.    devices */
  178.  
  179. #define ZERO 0
  180. #define MAXINT_F 255.0
  181. #define MAXINT_I 255
  182.  
  183.  /* dithering matrix */
  184. const static short int matrix[16][16] = {
  185.     {1, 235, 59, 219, 15, 231, 55, 215, 4, 234, 58, 218, 14, 230, 54, 214},
  186.     {129, 65, 187, 123, 143, 79, 183, 119, 132, 68, 186, 122, 142, 78, 182,
  187.      118},
  188.     {33, 193, 17, 251, 47, 207, 31, 247, 36, 196, 20, 250, 46, 206, 30, 246},
  189.     {161, 97, 145, 81, 175, 111, 159, 95, 164, 100, 148, 84, 174, 110, 158,
  190.      94},
  191.     {9, 225, 49, 209, 5, 239, 63, 223, 12, 228, 52, 212, 8, 238, 62, 222},
  192.     {137, 73, 177, 113, 133, 69, 191, 127, 140, 76, 180, 116, 136, 72, 190,
  193.      126},
  194.     {41, 201, 25, 241, 37, 197, 21, 255, 44, 204, 28, 244, 40, 200, 24, 254},
  195.     {169, 105, 153, 89, 165, 101, 149, 85, 172, 108, 156, 92, 168, 104, 152,
  196.      88},
  197.     {3, 233, 57, 217, 13, 229, 53, 213, 2, 236, 60, 220, 16, 232, 56, 216},
  198.     {131, 67, 185, 121, 141, 77, 181, 117, 130, 66, 188, 124, 144, 80, 184,
  199.      120},
  200.     {35, 195, 19, 249, 45, 205, 29, 245, 34, 194, 18, 252, 48, 208, 32, 248},
  201.     {163, 99, 147, 83, 173, 109, 157, 93, 162, 98, 146, 82, 176, 112, 160,
  202.      96},
  203.     {11, 227, 51, 211, 7, 237, 61, 221, 10, 226, 50, 210, 6, 240, 64, 224},
  204.     {139, 75, 179, 115, 135, 71, 189, 125, 138, 74, 178, 114, 134, 70, 192,
  205.      128},
  206.     {43, 203, 27, 243, 39, 199, 23, 253, 42, 202, 26, 242, 38, 198, 22, 256},
  207.     {171, 107, 155, 91, 167, 103, 151, 87, 170, 106, 154, 90, 166, 102, 150,
  208.      86}
  209.     };
  210.  
  211.  
  212.  
  213. XShpl_dither(PLANE *plane,PLANE_INFO *plane_info,LIMITS *limits,
  214.          double minval,double maxval,int pixsize,
  215.          int absolute,int negative,XImage *ximage)
  216. {
  217.     int runlevel;
  218.     int deltapllevel;
  219.     int roff,coff;
  220.     int xim_y_coord, xim_x_coord, rbitoff, bitoff, byteoff, bitbyte;
  221.     register int maskrow, maskcol, saved_maskcol, saved_maskrow;
  222.     register int ipixrow, ipixcol;
  223.     int crow,ccol;
  224.     int byte;
  225.     double intensity_scale,value_range,pixel,scaled_pixel,fback;
  226.     register short int *maskrow_ptr;
  227.  
  228.     if (autoscale) plane_min_max(plane,plane_info,limits,&minval,&maxval);
  229.  
  230.     saved_maskrow = maskrow = 0;
  231.  
  232.     runlevel = limits->level;
  233.  
  234.     if (plane_info->datatype == FLOAT) fback = plane_info->background.flonum;
  235.     else fback = plane_info->background.fixnum;
  236.  
  237.     deltapllevel = runlevel - plane_info->level;
  238.     value_range = maxval - minval;
  239.     intensity_scale = MAXINT_F / value_range;
  240.  
  241.     for (crow = limits->startrow;
  242.      crow <= limits->endrow;
  243.      crow += limits->deltarow) {
  244.  
  245.     saved_maskrow = (maskrow % 16);
  246.     maskcol = 0;
  247.  
  248.     TRANSLEVEL(roff,crow,deltapllevel,plane_info->row_location);
  249.     xim_y_coord = (crow - limits->startrow) * pixsize;
  250.  
  251.     for (ccol = limits->startcol;
  252.          ccol <= limits->endcol;
  253.          ccol += limits->deltacol) {
  254.  
  255.         TRANSLEVEL(coff,ccol,deltapllevel,plane_info->column_location);
  256.         xim_x_coord = (ccol - limits->startcol) * pixsize;
  257.     
  258.         maskrow = saved_maskrow;
  259.  
  260.         GET_PIXEL(pixel,fback,plane,roff,coff,
  261.                     (*plane_info));
  262.         if (absolute) pixel = fabs(pixel);
  263.     /* scale pixel.  out of range values get black or white.
  264.        otherwise linear mapping */
  265.         if (intensity_scale > 0.0) {
  266.         /* positive slope case */
  267.         if (pixel < minval)
  268.             scaled_pixel = 0.0;
  269.         else
  270.             if (pixel > maxval)
  271.             scaled_pixel = MAXINT_F;
  272.             else
  273.             scaled_pixel =(pixel - minval) *
  274.                 intensity_scale;
  275.         }
  276.         else {    /* negative slope case */
  277.         if (pixel < maxval)
  278.             scaled_pixel = MAXINT_F;
  279.         else
  280.             if (pixel > minval)
  281.             scaled_pixel = 0.0;
  282.             else
  283.             scaled_pixel =(pixel - minval) *
  284.                 intensity_scale;
  285.         }
  286.     byte = scaled_pixel + 0.5;
  287.     if (negative) byte = MAXINT_I - byte;
  288.     saved_maskcol = (maskcol % 16);
  289.     for (ipixrow=0;ipixrow<pixsize;ipixrow++) {
  290.         bitbyte = 1 << (bitoff & 0x07);
  291.         if (maskrow > 15) maskrow = 0;
  292.         maskrow_ptr = (&matrix[maskrow][0]);
  293.         maskcol = saved_maskcol;
  294.         for (ipixcol=0;ipixcol<pixsize;ipixcol++) {
  295.         if (maskcol > 15) maskcol = 0;
  296.     
  297.         if (maskrow_ptr[maskcol] < byte) {
  298.             XPutPixel(ximage,xim_x_coord+ipixcol,xim_y_coord+ipixrow,1);
  299.             }
  300.         bitbyte = bitbyte << 1;
  301.         if (bitbyte > 0x0080) {
  302.             bitbyte = 1;
  303.             }
  304.         maskcol++;
  305.         }
  306.         maskrow++;
  307.         }
  308.     }
  309.     }
  310. }
  311.  
  312.  
  313.