home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 625.lha / STScan_v2.0 / pixelop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-22  |  6.4 KB  |  271 lines
  1. /*pixelop.c pixel operations for stscan.c*/
  2. #include <exec/exec.h>
  3. #include <exec/types.h>
  4. #include <intuition/intuition.h>
  5. #include <intuition/intuitionbase.h>
  6. #include <libraries/dos.h>
  7. #include <libraries/dosextens.h>
  8. #include <graphics/rastport.h>
  9. #include <libraries/reqbase.h>
  10. #include <req_pragmas.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <functions.h>
  14. #include "stscan.h"
  15.  
  16. static ULONG histo[16];
  17.  
  18. void floyd()
  19. { signed short lbuf[2][4000];
  20.   UBYTE *grptr,*bwptr;
  21.   USHORT i,j;
  22.   signed short f,g;
  23.   char wtitel[20];
  24.  
  25.   g=(signed short)(winpar.threshold/4);
  26.   for (i=0;i<4000;i++) lbuf[0][i]=lbuf[1][i]=0;
  27.   grptr=bwptr=memptr;
  28.   for (i=0;i<memheight;i++)
  29.   { for (j=0;j<memwidth;j++)
  30.     { if (j&1) lbuf[0][j]=(signed short)(  (*(grptr+(j>>1)))     &15)+lbuf[1][j];
  31.       else     lbuf[0][j]=(signed short)(( (*(grptr+(j>>1))) >>4)&15)+lbuf[1][j];
  32.     }
  33.     for (j=0;j<(memwidth>>3);j++) *(bwptr+j)=0;
  34.     for (j=0;j<memwidth;j++)
  35.     { if (lbuf[0][j]<g) 
  36.       { f=lbuf[0][j];
  37.         *(bwptr+(j>>3))|=bitval[j&7];
  38.       }
  39.       else f=lbuf[0][j]-15;
  40.       lbuf[1][j]=(f+f+f)/8;
  41.       lbuf[1][j+1]=f-2*lbuf[1][j];
  42.       lbuf[0][j+1]+=((f+f+f)/8);
  43.     }
  44.     grptr+=(memwidth>>1);
  45.     bwptr+=(memwidth>>3);
  46.     if (!(i%100)) 
  47.     { sprintf(&wtitel,"Dithering %03d %%",i*100/memheight);
  48.       SetWindowTitles(win,&wtitel[0],(UBYTE *)-1);
  49.     }
  50.   }
  51.   memneed=(memwidth*memheight)>>3;
  52.   memgray=0;
  53.   if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>3)))
  54.   { memneed=0;
  55.     MessReq((UBYTE *)"Out Of Memory!");
  56.   }
  57.   SetWindowTitles(win," ",(UBYTE *)-1);
  58. }
  59.  
  60. void ordered()
  61. { UBYTE *grptr,*bwptr;
  62.   USHORT i,j;
  63.   char wtitel[20];
  64.   UBYTE refmat[4][4]={{0,7,2,9},{11,4,13,6},{3,10,1,8},{14,7,12,5}};
  65.   UBYTE v;
  66.  
  67.   grptr=bwptr=memptr;
  68.   for (i=0;i<memheight;i++)
  69.   { for (j=0;j<memwidth;j++)
  70.     { v=(j&1)?(  (*grptr)     &15)
  71.              :(( (*grptr) >>4)&15);
  72.       if (v>refmat[j&3][i&3]) *bwptr&=invbitval[j&7];
  73.       else *bwptr|=bitval[j&7];
  74.       if ((j&7)==7) bwptr++;
  75.       if (j&1) grptr++;
  76.     }
  77.     if (!(i%100)) 
  78.     { sprintf(&wtitel,"Dithering %03d %%",i*100/memheight);
  79.       SetWindowTitles(win,&wtitel[0],(UBYTE *)-1);
  80.     }
  81.   }
  82.   memneed=(memwidth*memheight)>>3;
  83.   memgray=0;
  84.   if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>3)))
  85.   { memneed=0;
  86.     MessReq((UBYTE *)"Out Of Memory!");
  87.   }
  88.   SetWindowTitles(win," ",(UBYTE *)-1);
  89. }
  90.  
  91. void thresh()
  92. { UBYTE *grptr,*bwptr;
  93.   USHORT i,j;
  94.   char wtitel[20];
  95.   UBYTE v,g;
  96.  
  97.   grptr=bwptr=memptr;
  98.   g=winpar.threshold/4;
  99.   for (i=0;i<memheight;i++)
  100.   { for (j=0;j<memwidth;j++)
  101.     { v=(j&1)?(  (*grptr)     &15)
  102.              :(( (*grptr) >>4)&15);
  103.       if (v>g) *bwptr&=invbitval[j&7];
  104.       else *bwptr|=bitval[j&7];
  105.       if ((j&7)==7) bwptr++;
  106.       if (j&1) grptr++;
  107.     }
  108.     if (!(i%100)) 
  109.     { sprintf(&wtitel,"Thresholding %03d %%",i*100/memheight);
  110.       SetWindowTitles(win,&wtitel[0],(UBYTE *)-1);
  111.     }
  112.   }
  113.   memneed=(memwidth*memheight)>>3;
  114.   memgray=0;
  115.   if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>3)))
  116.   { memneed=0;
  117.     MessReq((UBYTE *)"Out Of Memory!");
  118.   }
  119.   SetWindowTitles(win," ",(UBYTE *)-1);
  120. }
  121.  
  122. void togray()
  123. { UBYTE *bwptr,*grptr;
  124.   USHORT i,j;
  125.   char wtitel[20];
  126.   UBYTE v;
  127.   ULONG g;
  128.  
  129.   memneed=(memwidth*memheight)>>1;
  130.   if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>1)))
  131.   { memneed=0;
  132.     MessReq((UBYTE *)"Out Of Memory!");
  133.   }
  134.   else 
  135.   { memgray=1;
  136.     bwptr=memptr+((memwidth*memheight)>>3);
  137.     grptr=memptr+((memwidth*memheight)>>1);
  138.     for (i=0;i<memheight;i++)
  139.     { for (j=0;j<memwidth;j+=8)
  140.       { v= ~(*(--bwptr)); g=0;
  141.         if (v&128) g|=0xf0000000;
  142.         if (v& 64) g|=0x0f000000;
  143.         if (v& 32) g|=0x00f00000;
  144.         if (v& 16) g|=0x000f0000;
  145.         if (v&  8) g|=0x0000f000;
  146.         if (v&  4) g|=0x00000f00;
  147.         if (v&  2) g|=0x000000f0;
  148.         if (v&  1) g|=0x0000000f;
  149.         *(--grptr)=(UBYTE)(g&0xff);
  150.         *(--grptr)=(UBYTE)((g>>8)&0xff);
  151.         *(--grptr)=(UBYTE)((g>>16)&0xff);
  152.         *(--grptr)=(UBYTE)((g>>24)&0xff);
  153.       }
  154.       if (!(i%128)) 
  155.       { sprintf(&wtitel,"Converting %03d %%",i*100/memheight);
  156.         SetWindowTitles(win,&wtitel[0],(UBYTE *)-1);
  157.       }
  158.     }
  159.     SetWindowTitles(win," ",(UBYTE *)-1);
  160.   }
  161. }
  162.  
  163.  
  164. void invert()
  165. { UBYTE *picptr;
  166.   ULONG i;
  167.  
  168.   picptr=memptr;
  169.   for (i=0;i<memneed;i++) *(picptr++)=~(*picptr);
  170. }
  171.  
  172. void mirrorh()
  173. { UBYTE *picptr;
  174.   ULONG i,j;
  175.   UBYTE temp[4000];
  176.   ULONG bpl;
  177.  
  178.   bpl=(memgray)?(memwidth>>1):(memwidth>>3);
  179.   picptr=memptr;
  180.   if (memgray)
  181.     for (i=0;i<memheight;i++)
  182.     { memcpy(&temp[1],picptr,bpl);
  183.       for (j=bpl;j>0;j--)
  184.         *(picptr++)=(((temp[j]&0x0f)<<4)|((temp[j]&0xf0)>>4));
  185.     }
  186.   else 
  187.     for (i=0;i<memheight;i++)
  188.     { memcpy(&temp[1],picptr,bpl);
  189.       for (j=bpl;j>0;j--)
  190.         *(picptr++)=revbit[temp[j]];
  191.     }
  192. }
  193.  
  194. void mirrorv()
  195. { UBYTE *l1ptr,*l2ptr;
  196.   USHORT i;
  197.   UBYTE temp[4000];
  198.   ULONG bpl;
  199.  
  200.   bpl=(memgray)?(memwidth>>1):(memwidth>>3);
  201.   l1ptr=memptr;
  202.   l2ptr=memptr+(memheight-1)*bpl;
  203.   for (i=0;i<(memheight>>1);i++)
  204.   { memcpy(&temp[0],l1ptr,bpl);
  205.     memcpy(l1ptr,l2ptr,bpl);
  206.     memcpy(l2ptr,&temp[0],bpl);
  207.     l1ptr+=bpl;
  208.     l2ptr-=bpl;
  209.   }
  210. }
  211.  
  212. static void counthisto()
  213. { ULONG cnt;
  214.   UBYTE *picptr;
  215.   UBYTE i,b;
  216.  
  217.   for (i=0;i<16;i++) histo[i]=0;
  218.   picptr=memptr;
  219.   for (cnt=0;cnt<memneed;cnt++)
  220.   { b=*(picptr++);
  221.     histo[b&0x0f]++;
  222.     histo[(b>>4)&0x0f]++;
  223.   }
  224. }
  225.  
  226. void viewhisto(struct RastPort *wrp)
  227. { ULONG max=0;
  228.   UBYTE i;
  229.   UWORD ampl;
  230.   UBYTE *plptr[4];
  231.   
  232.   counthisto();
  233.   for (i=0;i<16;i++) if (histo[i]>max) max=histo[i];
  234.   for (i=0;i<4;i++) plptr[i]=(UBYTE *)(rp->BitMap->Planes[i]+1680);
  235.   clrscr(plptr[0],plptr[1],plptr[2],plptr[3]);
  236.   SetWrMsk(wrp,15);
  237.   SetDrMd(wrp,JAM1);
  238.   SetDrPt(wrp,0xffff);
  239.   SetAPen(wrp,1);
  240.   Move(wrp,50,390); Draw(wrp,529,390);
  241.   for(i=0;i<16;i++)
  242.   { SetAPen(wrp,1);
  243.     ampl=histo[i]*350/max;
  244.     Move(wrp,50+i*30,390);
  245.     Draw(wrp,50+i*30,390-ampl);
  246.     Draw(wrp,79+i*30,390-ampl);
  247.     Draw(wrp,79+i*30,390);
  248.     if (ampl>1)
  249.     { SetAPen(wrp,(i+1)&0x0f);
  250.       RectFill(wrp,51+i*30,391-ampl,78+i*30,389);
  251.     }
  252.   }
  253. }
  254.         
  255. void stretchhisto()
  256. { ULONG integ[16];
  257.   UBYTE lut[16];
  258.   UBYTE largelut[256];
  259.   UWORD i;
  260.   ULONG cnt;
  261.   UBYTE *picptr;
  262.  
  263.   counthisto();
  264.   integ[0]=histo[0];
  265.   for(i=1;i<16;i++) integ[i]=histo[i]+integ[i-1];
  266.   for(i=0;i<16;i++) lut[i]=(UBYTE)((integ[i]*15)/integ[15])&0x0f;
  267.   for(i=0;i<256;i++) largelut[i]=(((lut[(i>>4)&0x0f])<<4)|(lut[i&0x0f]));
  268.   picptr=memptr;
  269.   for(cnt=0;cnt<memneed;cnt++) {*picptr=largelut[*picptr]; picptr++; }
  270. }
  271.