开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
Image.cc
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：24k
源码类别：

3D图形编程

开发平台：

Visual C++

Image.cc：源码内容
  1. //############################################################
  2. // Image.cc
  3. // Kari Pulli
  4. // 10/25/95
  5. //############################################################
  7. #include <iostream.h>
  8. #include <fstream.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <assert.h>
  12. #include <string.h>
  13. #include <strings.h>
  14. #include <math.h>
  15. #include "Image.h"
  16. #ifndef linux
  17. #include <ifl/iflFile.h>
  18. #endif
  21. ////////////////////////////////////////////////////////////////
  22. ////////////////////////////////////////////////////////////////
  23. ////////////////////////////////////////////////////////////////
  26. void
  27. bwtorgba(unsigned char *b,unsigned char *l,int n) 
  28. {
  29.   while(n--) {
  30.     l[0] = *b;
  31.     l[1] = *b;
  32.     l[2] = *b;
  33.     l[3] = 0xff;
  34.     l += 4; b++;
  35.   }
  36. }
  38. void
  39. bwtorgb(unsigned char *b,unsigned char *l,int n) 
  40. {
  41.   while(n--) {
  42.     l[0] = *b;
  43.     l[1] = *b;
  44.     l[2] = *b;
  45.     l += 3; b++;
  46.   }
  47. }
  49. void
  50. rgbtorgba(unsigned char *r,unsigned char *g,unsigned char *b,
  51.   unsigned char *l,int n) 
  52. {
  53.   while(n--) {
  54.     l[0] = r[0];
  55.     l[1] = g[0];
  56.     l[2] = b[0];
  57.     l[3] = 0xff;
  58.     l += 4; r++; g++; b++;
  59.   }
  60. }
  62. void
  63. rgbatorgba(unsigned char *r,unsigned char *g,unsigned char *b,
  64.    unsigned char *a,unsigned char *l,int n) 
  65. {
  66.   while(n--) {
  67.     l[0] = r[0];
  68.     l[1] = g[0];
  69.     l[2] = b[0];
  70.     l[3] = a[0];
  71.     l += 4; r++; g++; b++; a++;
  72.   }
  73. }
  75. void
  76. rgbtorgb(unsigned char *r,unsigned char *g,unsigned char *b,
  77.  unsigned char *l,int n) 
  78. {
  79.   while(n--) {
  80.     l[0] = r[0];
  81.     l[1] = g[0];
  82.     l[2] = b[0];
  83.     l += 3; r++; g++; b++;
  84.   }
  85. }
  87. typedef struct _ImageRec {
  88.   unsigned short imagic;
  89.   unsigned short type;
  90.   unsigned short dim;
  91.   unsigned short xsize, ysize, zsize;
  92.   unsigned int min, max;
  93.   unsigned int wasteBytes;
  94.   char name[80];
  95.   unsigned long colorMap;
  96.   FILE *file;
  97.   unsigned char *tmp, *tmpR, *tmpG, *tmpB;
  98.   unsigned long rleEnd;
  99.   unsigned int *rowStart;
  100.   int *rowSize;
  101. } ImageRec;
  103. static void
  104. ConvertShort(unsigned short *array, long length) 
  105. {
  106.   unsigned long b1, b2;
  107.   unsigned char *ptr;
  108.   
  109.   ptr = (unsigned char *)array;
  110.   while (length--) {
  111.     b1 = *ptr++;
  112.     b2 = *ptr++;
  113.     *array++ = (b1 << 8) | (b2);
  114.   }
  115. }
  117. static void
  118. ConvertLong(unsigned *array, long length) 
  119. {
  120.   unsigned long b1, b2, b3, b4;
  121.   unsigned char *ptr;
  122.   
  123.   ptr = (unsigned char *)array;
  124.   while (length--) {
  125.     b1 = *ptr++;
  126.     b2 = *ptr++;
  127.     b3 = *ptr++;
  128.     b4 = *ptr++;
  129.     *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  130.   }
  131. }
  133. static ImageRec *
  134. ImageOpen(const char *fileName)
  135. {
  136.   union {
  137.     int  testWord;
  138.     char testByte[4];
  139.   } endianTest;
  140.   ImageRec *image;
  141.   int swapFlag;
  142.   int x;
  143.   
  144.   endianTest.testWord = 1;
  145.   if (endianTest.testByte[0] == 1) {
  146.     swapFlag = 1;
  147.   } else {
  148.     swapFlag = 0;
  149.   }
  150.   
  151.   image = (ImageRec *)malloc(sizeof(ImageRec));
  152.   if (image == NULL) {
  153.     fprintf(stderr, "Image: Out of memory!n");
  154.     exit(1);
  155.   }
  156.   if ((image->file = fopen(fileName, "rb")) == NULL) {
  157.     perror(fileName);
  158.     exit(1);
  159.   }
  160.   
  161.   fread(image, 1, 12, image->file);
  162.   
  163.   if (swapFlag) {
  164.     ConvertShort(&image->imagic, 6);
  165.   }
  166.   
  167.   image->tmp  = (unsigned char *)malloc(image->xsize*256);
  168.   image->tmpR = (unsigned char *)malloc(image->xsize*256);
  169.   image->tmpG = (unsigned char *)malloc(image->xsize*256);
  170.   image->tmpB = (unsigned char *)malloc(image->xsize*256);
  171.   if (image->tmp  == NULL || image->tmpR == NULL || 
  172.       image->tmpG == NULL || image->tmpB == NULL) {
  173.     fprintf(stderr, "Image: Out of memory!n");
  174.     exit(1);
  175.   }
  176.   
  177.   if ((image->type & 0xFF00) == 0x0100) {
  178.     x = image->ysize * image->zsize * sizeof(unsigned);
  179.     image->rowStart = (unsigned *)malloc(x);
  180.     image->rowSize = (int *)malloc(x);
  181.     if (image->rowStart == NULL || image->rowSize == NULL) {
  182.       fprintf(stderr, "Image: Out of memory!n");
  183.       exit(1);
  184.     }
  185.     image->rleEnd = 512 + (2 * x);
  186.     fseek(image->file, 512, SEEK_SET);
  187.     fread(image->rowStart, 1, x, image->file);
  188.     fread(image->rowSize, 1, x, image->file);
  189.     if (swapFlag) {
  190.       ConvertLong(image->rowStart, x/sizeof(unsigned));
  191.       ConvertLong((unsigned *)image->rowSize, x/sizeof(int));
  192.     }
  193.   }
  194.   return image;
  195. }
  197. static void
  198. ImageClose(ImageRec *image) 
  199. {
  200.   fclose(image->file);
  201.   free(image->tmp);
  202.   free(image->tmpR);
  203.   free(image->tmpG);
  204.   free(image->tmpB);
  205.   free(image);
  206. }
  208. static void
  209. ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) 
  210. {
  211.   unsigned char *iPtr, *oPtr, pixel;
  212.   int count;
  213.   
  214.   if ((image->type & 0xFF00) == 0x0100) {
  215.     fseek(image->file, image->rowStart[y+z*image->ysize], SEEK_SET);
  216.     fread(image->tmp, 1, (unsigned int)
  217.   image->rowSize[y+z*image->ysize], image->file);
  218.     
  219.     iPtr = image->tmp;
  220.     oPtr = buf;
  221.     while (1) {
  222.       pixel = *iPtr++;
  223.       count = (int)(pixel & 0x7F);
  224.       if (!count) {
  225. return;
  226.       }
  227.       if (pixel & 0x80) {
  228. while (count--) {
  229.   *oPtr++ = *iPtr++;
  230. }
  231.       } else {
  232. pixel = *iPtr++;
  233. while (count--) {
  234.   *oPtr++ = pixel;
  235. }
  236.       }
  237.     }
  238.   } else {
  239.     fseek(image->file, 512+(y*image->xsize)+
  240.   (z*image->xsize*image->ysize), SEEK_SET);
  241.     fread(buf, 1, image->xsize, image->file);
  242.   }
  243. }
  245. unsigned *
  246. read_texture(char *name, int *width, int *height, int *components) 
  247. {
  248.   unsigned *base, *lptr;
  249.   unsigned char *rbuf, *gbuf, *bbuf, *abuf;
  250.   ImageRec *image;
  251.   int y;
  252.   
  253.   image = ImageOpen(name);
  254.   
  255.   if(!image)
  256.     return NULL;
  257.   (*width)=image->xsize;
  258.   (*height)=image->ysize;
  259.   (*components)=image->zsize;
  260.   base = (unsigned *)malloc((*width)*(*height)*sizeof(unsigned));
  261.   rbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  262.   gbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  263.   bbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  264.   abuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  265.   if(!base || !rbuf || !gbuf || !bbuf)
  266.     return NULL;
  267.   lptr = base;
  268.   for(y=0; y<image->ysize; y++) {
  269.     if(image->zsize>=4) {
  270.       ImageGetRow(image,rbuf,y,0);
  271.       ImageGetRow(image,gbuf,y,1);
  272.       ImageGetRow(image,bbuf,y,2);
  273.       ImageGetRow(image,abuf,y,3);
  274.       rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr, 
  275.        image->xsize);
  276.       lptr += image->xsize;
  277.     } else if(image->zsize==3) {
  278.       ImageGetRow(image,rbuf,y,0);
  279.       ImageGetRow(image,gbuf,y,1);
  280.       ImageGetRow(image,bbuf,y,2);
  281.       rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
  282.       lptr += image->xsize;
  283.     } else {
  284.       ImageGetRow(image,rbuf,y,0);
  285.       bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
  286.       lptr += image->xsize;
  287.     }
  288.   }
  289.   ImageClose(image);
  290.   free(rbuf);
  291.   free(gbuf);
  292.   free(bbuf);
  293.   free(abuf);
  294.   
  295.   return (unsigned *) base;
  296. }
  298. unsigned *
  299. read_textureRGB(char *name, int *width, int *height) 
  300. {
  301.   unsigned *base, *lptr;
  302.   unsigned char *rbuf, *gbuf, *bbuf, *abuf;
  303.   ImageRec *image;
  304.   int y;
  305.   
  306.   image = ImageOpen(name);
  307.   
  308.   if(!image)
  309.     return NULL;
  310.   (*width)=image->xsize;
  311.   (*height)=image->ysize;
  312.   base = (unsigned *)malloc((*width)*(*height)*sizeof(unsigned));
  313.   rbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  314.   gbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  315.   bbuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  316.   abuf = (unsigned char *)malloc((*width)*sizeof(unsigned char));
  317.   if(!base || !rbuf || !gbuf || !bbuf)
  318.     return NULL;
  319.   lptr = base;
  320.   for(y=0; y<image->ysize; y++) {
  321.     if(image->zsize>=4) {
  322.       ImageGetRow(image,rbuf,y,0);
  323.       ImageGetRow(image,gbuf,y,1);
  324.       ImageGetRow(image,bbuf,y,2);
  325.       ImageGetRow(image,abuf,y,3);
  326.       rgbtorgb(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
  327.       lptr += image->xsize;
  328.     } else if(image->zsize==3) {
  329.       ImageGetRow(image,rbuf,y,0);
  330.       ImageGetRow(image,gbuf,y,1);
  331.       ImageGetRow(image,bbuf,y,2);
  332.       rgbtorgb(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
  333.       lptr += image->xsize;
  334.     } else {
  335.       ImageGetRow(image,rbuf,y,0);
  336.       bwtorgb(rbuf,(unsigned char *)lptr,image->xsize);
  337.       lptr += image->xsize;
  338.     }
  339.   }
  340.   ImageClose(image);
  341.   free(rbuf);
  342.   free(gbuf);
  343.   free(bbuf);
  344.   free(abuf);
  345.   
  346.   return (unsigned *) base;
  347. }
  350. ////////////////////////////////////////////////////////////////
  351. ////////////////////////////////////////////////////////////////
  352. ////////////////////////////////////////////////////////////////
  356. void 
  357. Image::create(const int w, const int h, const int d)
  358. {
  359.   if (w*h*d > xsize*ysize*dim) {
  360.     // need more room
  361.     delete[] data;
  362.     delete[] _data;
  363.     _data = new uchar[w*h*d];
  364.     data =  new uchar *[h];
  365.   }
  366.   if (w != xsize || d != dim) {
  367.     for (int i=0; i<h; i++) data[i] = &_data[w*d*i];
  368.     xsize = w;  dim = d;
  369.   }
  370.   ysize = h;
  371. }  
  373. Image::Image()
  374. : xsize(0), ysize(0), data(NULL), _data(NULL), dim(0)
  375. {
  376. }
  379. Image::Image(const Image& a)
  380. : xsize(0), ysize(0), dim(0), data(NULL), _data(NULL)
  381. {
  382.   create(a.xsize, a.ysize, a.dim);
  383.   //bcopy(a._data, _data, xsize*ysize*dim);
  384.   memcpy(_data, a._data, xsize*ysize*dim);
  385. }
  387. Image &
  388. Image::operator=(const Image& a)
  389. {
  390.   if (&a != this) {
  391.     //xsize = ysize = dim = 0;
  392.     //data = NULL;
  393.     //_data = NULL;
  394.     create(a.xsize, a.ysize, a.dim);
  395.     //bcopy(a._data, _data, xsize*ysize*dim);
  396.     memcpy(_data, a._data, xsize*ysize*dim);
  397.   }
  398.   return *this;
  399. }
  402. Image::Image(const int w, const int h, const int d)
  403. : data(NULL), _data(NULL), dim(0)
  404. {
  405.   create (w,h,d);
  406. }
  409. Image::~Image()
  410. {
  411.   delete[] data;
  412.   delete[] _data;
  413. }
  416. ostream &operator <<(ostream &out, Image &im)
  417. {
  418.   out << im.xsize << " x " << im.ysize << " image";
  419.   return out;
  420. }
  422. /*
  423. void 
  424. Image::rgb2bw()
  425. {
  426.   unsigned char tmp;
  427.   if (bw == 1) return;
  428.   for (int i=0; i<xsize*ysize; i++) {
  429.     tmp = (unsigned char)(double(_data[i].red())   * 0.30 +
  430.   double(_data[i].green()) * 0.59 +
  431.   double(_data[i].blue())  * 0.11);
  432.     _data[i] = Pixel(tmp, tmp, tmp);
  433.   }
  434.   bw = 1;
  435. }
  436. */
  438. void
  439. Image::toRGBA(void)
  440. {
  441.   assert(data && _data);
  443.   if (dim == 4) return;
  445.   uchar *new_data = new uchar[xsize*ysize*4];
  447.   uchar *ptr_old = _data;
  448.   uchar *ptr_new = new_data;
  449.   for (int i=0; i<xsize*ysize; i++) {
  450.     uchar tmp = *ptr_old++;
  451.     if        (dim == 3) {
  452.       *ptr_new++ = tmp;
  453.       *ptr_new++ = *ptr_old++;
  454.       *ptr_new++ = *ptr_old++;
  455.       *ptr_new++ = 255;
  456.     } else if (dim == 1) {
  457.       *ptr_new++ = tmp;
  458.       *ptr_new++ = tmp;
  459.       *ptr_new++ = tmp;
  460.       *ptr_new++ = 255;
  461.     } else if (dim == 2) {
  462.       *ptr_new++ = tmp;
  463.       *ptr_new++ = tmp;
  464.       *ptr_new++ = tmp;
  465.       *ptr_new++ = *ptr_old++;
  466.     }     
  467.   }
  468.   delete[] _data;
  469.   _data = new_data;
  470.   dim = 4;
  471.   for (i=0; i<ysize; i++) data[i] = &_data[xsize*dim*i];
  472. }
  475. void
  476. Image::toRGB(void)
  477. {
  478.   assert(data && _data);
  480.   if (dim == 3) return;
  482.   uchar *new_data = new uchar[xsize*ysize*3];
  484.   uchar *ptr_old = _data;
  485.   uchar *ptr_new = new_data;
  486.   for (int i=0; i<xsize*ysize; i++) {
  487.     uchar tmp = *ptr_old++;
  488.     if        (dim == 4) {
  489.       *ptr_new++ = tmp;
  490.       *ptr_new++ = *ptr_old++;
  491.       *ptr_new++ = *ptr_old++;
  492.       ptr_old++;
  493.     } else if (dim == 1) {
  494.       *ptr_new++ = tmp;
  495.       *ptr_new++ = tmp;
  496.       *ptr_new++ = tmp;
  497.     } else if (dim == 2) {
  498.       *ptr_new++ = tmp;
  499.       *ptr_new++ = tmp;
  500.       *ptr_new++ = tmp;
  501.       ptr_old++;
  502.     }     
  503.   }
  504.   delete[] _data;
  505.   _data = new_data;
  506.   dim = 3;
  507.   for (i=0; i<ysize; i++) data[i] = &_data[xsize*dim*i];
  508. }
  510. void 
  511. Image::RGB2HSV(void)
  512. {
  513.   assert(dim == 3);
  514.   float h,s,min,max; // max == v
  515.   for (int v=0; v<ysize; v++) {
  516.     for (int u=0; u<xsize; u++) {
  517.       uchar *tmp = getValues(u,v);
  518.       min = max = tmp[0];
  519.       if      (tmp[1] < min) min = tmp[1];
  520.       else if (tmp[1] > max) max = tmp[1];
  521.       if      (tmp[2] < min) min = tmp[2];
  522.       else if (tmp[2] > max) max = tmp[2];
  524.       if (max != 0) s = (max - min)/max;
  525.       else          s = 0;
  527.       if (s == 0)   h = 0;
  528.       else {
  529. float delta = max - min;
  530. if      (tmp[0] == max) h = (tmp[1]-tmp[2])/delta;
  531. else if (tmp[1] == max) h = 2 + (tmp[2]-tmp[0])/delta;
  532. else if (tmp[2] == max) h = 4 + (tmp[0]-tmp[1])/delta;
  533. if (h < 0.0) h += 6.0;
  534. h /= 6.0;
  535.       }
  536.       tmp[0] = h*255.0;
  537.       //tmp[1] = s*255.0;
  538.       //tmp[0] = max*h;
  539.       tmp[1] = max*s;
  540.       tmp[2] = max;
  541.     }
  542.   }
  543. }
  545. void 
  546. Image::HSV2RGB(void)
  547. {
  548.   assert(dim == 3);
  549.   float h,s;
  550.   for (int v=0; v<ysize; v++) {
  551.     for (int u=0; u<xsize; u++) {
  552.       uchar *tmp = getValues(u,v);
  553.       if (tmp[1] == 0) {
  554. // zero saturation
  555. tmp[0] = tmp[1] = tmp[2];
  556.       } else {
  557. if (tmp[0] == 255) h = 0.0;
  558. else               h = tmp[0]/255.0 * 6.0;
  559. int i = floor(h);
  560. float f = h - i;
  561. s = float(tmp[1]) / float(tmp[2]);
  562. float p = tmp[2] * (1.0-s);
  563. float q = tmp[2] * (1.0-s * f);
  564. float t = tmp[2] * (1.0-s * (1.0-f));
  565. switch(i) {
  566. case 0:
  567.   tmp[0] = tmp[2];
  568.   tmp[1] = t;
  569.   tmp[2] = p;
  570.   break;
  571. case 1:
  572.   tmp[0] = q;
  573.   tmp[1] = tmp[2];
  574.   tmp[2] = p;
  575.   break;
  576. case 2:
  577.   tmp[0] = p;
  578.   tmp[1] = tmp[2];
  579.   tmp[2] = t;
  580.   break;
  581. case 3:
  582.   tmp[0] = p;
  583.   tmp[1] = q;
  584.   //tmp[2] = tmp[2];
  585.   break;
  586. case 4:
  587.   tmp[0] = t;
  588.   tmp[1] = p;
  589.   //tmp[2] = tmp[2];
  590.   break;
  591. case 5:
  592.   tmp[0] = tmp[2];
  593.   tmp[1] = p;
  594.   tmp[2] = q;
  595.   break;
  596. }
  597.       }
  598.     }
  599.   }
  600. }
  602. void 
  603. Image::RGB2rgI(void)
  604. {
  605.   assert(dim == 3);
  606.   for (int v=0; v<ysize; v++) {
  607.     for (int u=0; u<xsize; u++) {
  608.       uchar *tmp = getValues(u,v);
  609.       int sum = int(tmp[0]) + int(tmp[1]) + int(tmp[2]);
  610.       if (sum < 10) {
  611. tmp[0] = tmp[1] = 85;
  612. tmp[2] = (sum / 3.0) + .5;
  613.       } else {
  614. tmp[0] = 255.0 * float(tmp[0]) / sum;
  615. tmp[1] = 255.0 * float(tmp[1]) / sum;
  616. tmp[2] = (sum / 3.0) + .5;
  617. if (sum < 45) {
  618.   float frac = float(45-sum)/36.0;
  619.   tmp[0] += (85-int(tmp[0])) * frac;
  620.   tmp[1] += (85-int(tmp[1])) * frac;
  621. }
  622.       }
  623.     }
  624.   }
  625. }
  627. void 
  628. Image::rgI2RGB(void)
  629. {
  630.   assert(dim == 3);
  631.   for (int v=0; v<ysize; v++) {
  632.     for (int u=0; u<xsize; u++) {
  633.       uchar *tmp = getValues(u,v);
  634.       uchar b = 255 - tmp[0] - tmp[1];
  635.       float frac = 3.0 * tmp[2] / 255.0;
  636.       tmp[0] = frac * tmp[0];
  637.       tmp[1] = frac * tmp[1];
  638.       tmp[2] = frac * b;
  639.     }
  640.   }
  641. }
  643. void
  644. Image::resize(int w, int h)
  645. {
  646.   // get new memory
  647.   uchar *n_data = new uchar[w*h*dim];
  648.   uchar **ndata = new uchar *[h];
  649.   for (int i=0; i<h; i++) ndata[i] = &n_data[w*dim*i];
  650.   // copy the data
  651.   int maxy = (h > ysize ? ysize : h);
  652.   int maxx = (w > xsize ? xsize : w);
  653.   for (i=0; i<maxy; i++) 
  654.     //bcopy(&_data[i*xsize*dim], &n_data[i*w*dim], maxx*dim);
  655.     memcpy(&n_data[i*w*dim], &_data[i*xsize*dim], maxx*dim);
  656.   // delete old space
  657.   delete[] data;
  658.   delete[] _data;
  659.   // write the correct info
  660.   _data = n_data;
  661.   data  = ndata;
  662.   xsize = w;
  663.   ysize = h;
  665. }
  668. void
  669. Image::flip(void)
  670. {
  671.   int row = dim*xsize;
  672.   uchar *buf = new uchar[row];
  673.  
  674.   for (int i=0; i<ysize/2; i++) {
  675.     memcpy(buf, data[i], row);
  676.     memcpy(data[i], data[ysize-i-1], row);
  677.     memcpy(data[ysize-i-1], buf, row);    
  678.   }
  679.  
  680.   delete[] buf;
  681. }
  683. // assume input is a single channel image with values 0 and 255
  684. // calculate distances from 0 by looking at neighbors and 
  685. // replacing the value with the min(nbors) + 1
  686. // do i iterations
  687. // use 8-nborhood
  688. // note: writes over itself while processing
  689. void
  690. Image::distances(int iter)
  691. {
  692.   for (int i=0; i<iter; i++) {
  693.     int vi = i%2;
  694.     for (int v=vi?0:ysize-1; 
  695.  vi?(v<ysize):(v>=0);
  696.  vi?v++:v--) {
  697.       int ui = (i%4)>>1;
  698.       for (int u=ui?0:xsize-1; 
  699.    ui?(u<xsize):(u>=0);
  700.    ui?u++:u--) {
  701. if (getR(u,v) == 0) continue;
  702. int min = 255;
  703. for (int j=-1; j<=1; j++) {
  704.   for (int k=-1; k<=1; k++) {
  705.     if (k==0 && j==0) continue;
  706.     if (inside(u+j, v+k)) {
  707.       uchar tmp = getR(u+j, v+k);
  708.       if (tmp < min) min = tmp;
  709.     }
  710.   }
  711. }
  712. if (min < 255) setValue(u,v,min+1);
  713.       }
  714.     }
  715.   }
  716. }
  718. // assume input is a single channel image with values 0 and 255
  719. // calculate distances from 0, use 4-nborhood
  720. // a fast inaccurate scanline version
  721. // note: writes over itself while processing
  722. void
  723. Image::dist4fast(void)
  724. {
  725.   int u,v;
  726.   // scan left to right
  727.   for (v=0; v<ysize; v++) {
  728.     uchar *ptr = &data[v][0];
  729.     for (u=1; u<xsize; u++, ptr++) {
  730.       if (ptr[1] > ptr[0]) ptr[1] = ptr[0]+1;
  731.     }
  732.   }
  733.   // scan down to up
  734.   for (u=0; u<xsize; u++) {
  735.     uchar *ptr = &data[0][u];
  736.     for (v=1; v<ysize; v++, ptr+=xsize) {
  737.       if (ptr[xsize] > ptr[0]) ptr[xsize] = ptr[0]+1;
  738.     }
  739.   }
  740.   // scan right to left
  741.   for (v=0; v<ysize; v++) {
  742.     uchar *ptr = &data[v][xsize-2];
  743.     for (u=xsize-2; u>=0; u--, ptr--) {
  744.       if (ptr[0] > ptr[1]) ptr[0] = ptr[1]+1;
  745.     }
  746.   }
  747.   // scan up to down
  748.   for (u=0; u<xsize; u++) {
  749.     uchar *ptr = &data[ysize-2][u];
  750.     for (v=ysize-2; v>=0; v--, ptr-=xsize) {
  751.       if (ptr[0] > ptr[xsize]) ptr[0] = ptr[xsize]+1;
  752.     }
  753.   }
  754. }
  756. int 
  757. Image::read(const char *fname, Format format, int w, int h)
  758. {
  759.   int i;
  760.   if (w==0) {
  761.     w=xsize; h=ysize;
  762.   }
  763.   
  764.   switch (format) {
  765.   case WSU:
  766.     {
  767.       ifstream from (fname);
  768.       if (!from) {
  769. cerr << "Cannot open inputfile " << fname << endl;
  770. return 0;
  771.       }
  772.       create (w, h, 1);
  773.       for (i=h-1; i>=0; i--)
  774. from.read(&_data[i*w], w);
  775.     }
  776.     break;
  777.   case SGI:
  778. #ifndef linux
  779.     {
  780.       iflStatus sts;
  781.       iflFile* file = iflFile::open(fname, O_RDONLY, &sts);
  782.       if (sts != iflOKAY) {
  783. cerr << "Cannot open inputfile " << fname << endl;
  784. return 0;
  785.       }
  786.       // read the entire image (just the first plane in z if image has depth)
  787.       // into a buffer of unsiged chars
  788.       iflSize dims;
  789.       file->getDimensions(dims);
  790. //      unsigned char* data = new unsigned char[dims.x*dims.y*dims.c];
  791. //      assert(dims.c == 1 || dims.c == 3);
  792. //      assert(w == dims.x && h == dims.y);
  793.       create(dims.x, dims.y, dims.c);
  794.       iflConfig cfg(iflUChar, iflInterleaved);
  795.       sts = file->getTile(0, 0, 0, dims.x, dims.y, 1, _data, &cfg);
  796.       if (sts != iflOKAY) {
  797. cerr << "Failed reading inputfile " << fname << endl;
  798. return 0;
  799.       }
  800.       // close the file
  801.       file->close();
  803.       /*      
  804.       ImageRec *image = ImageOpen(fname);
  805.       
  806.       if (!image) return 0;
  807.       
  808.       create(image->xsize, image->ysize, image->zsize);
  810.       uchar *rbuf = new uchar[xsize];
  811.       uchar *gbuf = new uchar[xsize];
  812.       uchar *bbuf = new uchar[xsize];
  813.       if (!rbuf || !gbuf || !bbuf) return NULL;
  815.       uchar *lptr = _data;
  816.       int step = 3*xsize;
  817.       for (int y=0; y<image->ysize; y++) {
  818. ImageGetRow(image,rbuf,y,0);
  819. if (image->zsize>=4) {
  820.   ImageGetRow(image,gbuf,y,1);
  821.   ImageGetRow(image,bbuf,y,2);
  822.   rgbtorgb(rbuf,gbuf,bbuf,lptr,xsize);
  823.   ImageGetRow(image,rbuf,y,3);
  824. } else if (image->zsize==3) {
  825.   ImageGetRow(image,gbuf,y,1);
  826.   ImageGetRow(image,bbuf,y,2);
  827.   rgbtorgb(rbuf,gbuf,bbuf,lptr,xsize);
  828. } else {
  829.   bwtorgb(rbuf,lptr,xsize);
  830. }
  831. lptr += step;
  832.       }
  833.       ImageClose(image);
  834.       delete[] rbuf;
  835.       delete[] gbuf;
  836.       delete[] bbuf;
  837.       */
  838.     }
  839.     break;
  840. #else
  841.     return 0;
  842. #endif
  843.   case RAWRGB:
  844.     {
  845.       ifstream from (fname);
  846.       if (!from) {
  847. cerr << "Cannot open inputfile " << fname << endl;
  848. return 0;
  849.       }
  850.       create(w,h,3);
  851.       from.read(_data, w*h*3);
  852.     }
  853.     break;
  854.   case FLOATRGB:
  855.     {
  856.       ifstream from (fname);
  857.       if (!from) {
  858. cerr << "Cannot open inputfile " << fname << endl;
  859. return 0;
  860.       }
  861.       int cnt = w*h*3;
  862.       float *tmp = new float[cnt];
  863.       create(w,h,3);
  864.       from.read((char *)tmp, cnt*sizeof(float));
  865.       for (i=0; i<cnt; i++) {
  866. _data[i] = (uchar)(255.999999 * tmp[i]);
  867.       }
  868.     }
  869.     break;
  870.   default:
  871.     cerr << "Unrecognized format" << endl;
  872.     return 0;
  873.   }
  874.   return 1;
  875. }
  877. int 
  878. Image::write(const char *fname, Format format)
  879. {
  880.   switch (format) {
  881.   case WSU:
  882.     {
  883.       cout << "Saving raw" << endl;
  884.       ofstream to (fname);
  885.       if (!to) {
  886. cerr << "Cannot open outputfile " << fname << endl;
  887. return 0;
  888.       }
  889.       for (int i=ysize-1; i>=0; i--)
  890. to.write(&_data[i*xsize], xsize);
  891.     }
  892.     break;
  893.   case SGI:
  894. #ifndef linux
  895.     {
  896.       cout << "Saving rgb" << endl;
  897.       // create a one-channel, unsigned char image file
  898.       iflSize dims(xsize, ysize, dim);
  899.       iflFileConfig fc(&dims, iflUChar);
  900.       fc.setCompression(iflSGIRLE);
  901.       iflStatus sts;
  902.       iflFile* file = iflFile::create(fname, NULL, &fc,NULL,&sts);
  903.       if (sts != iflOKAY) {
  904. cerr << "Error in creating file " << fname << endl;
  905. return 0;
  906.       }
  907.       // write a tile of data to it
  908.       sts = file->setTile(0, 0, 0, xsize, ysize, 1, _data);
  909.       if (sts != iflOKAY) {
  910. cerr <<"Error in setting the tile for file "<<fname<<endl;
  911. return 0;
  912.       }
  913.       file->close();
  914.     }
  915.     break;
  916. #else
  917.     return 0;
  918. #endif
  919.   default:
  920.     cerr << "Unknown format" << endl;
  921.     return 0;
  922.   }
  923.   int i=0;
  924.   i++;
  925.   return i;
  926. }
  929. Image
  930. Image::shrink(int factor) const
  931. {
  932.   int sx = xsize/factor;
  933.   int sy = ysize/factor;
  934.   Image simg(sx, sy, dim);
  936.   int fact2 = factor*factor;
  937.   uchar col[4];
  938.   col[0] = col[1] = col[2] = col[3] = 0;
  939.   for (int v=0; v<sy; v++) {
  940.     int y = v*factor;
  941.     for (int u=0; u<sx; u++) {
  942.       int x = u*factor;
  943.       for (int d=0; d<dim; d++) {
  944. int tmp = 0;
  945. for (int i=0; i<factor; i++) {
  946.   for (int j=0; j<factor; j++) {
  947.     tmp += at(x+i, y+j)[d];
  948.   }
  949. }
  950. col[d] = (tmp + fact2/2) / fact2;
  951.       }
  952.       simg.setValue(u,v,col[0],col[1],col[2],col[3]);
  953.     }
  954.   }
  955.   return simg;
  956. }
  959. void
  960. Image::shrink_by_half(Image &simg) const
  961. {
  962.   int sx = xsize>>1;
  963.   int sy = ysize>>1;
  964.   simg.create(sx, sy, dim);
  966.   int tmp[4];
  967.   int u,v,x,y;
  968.   uchar *ptr;
  969.   if (dim == 4) {
  970.     for (v=0,y=0; v<sy; v++, y+=2) {
  971.       for (u=0,x=0; u<sx; u++, x+=2) {
  972. ptr = at(x,y);
  973. tmp[0] = ptr[0] + ptr[4];
  974. tmp[1] = ptr[1] + ptr[5];
  975. tmp[2] = ptr[2] + ptr[6];
  976. tmp[3] = ptr[3] + ptr[7];
  977. ptr += xsize*4;
  978. tmp[0] += ptr[0] + ptr[4];
  979. tmp[1] += ptr[1] + ptr[5];
  980. tmp[2] += ptr[2] + ptr[6];
  981. tmp[3] += ptr[3] + ptr[7];
  982. ptr = simg.getValues(u,v);
  983. ptr[0] = (tmp[0]+2)>>2;
  984. ptr[1] = (tmp[1]+2)>>2;
  985. ptr[2] = (tmp[2]+2)>>2;
  986. ptr[3] = (tmp[3]+2)>>2;
  987.       }
  988.     }
  989.   } else if (dim == 3) {
  990.     for (v=0,y=0; v<sy; v++, y+=2) {
  991.       for (u=0,x=0; u<sx; u++, x+=2) {
  992. ptr = at(x,y);
  993. tmp[0] = ptr[0] + ptr[3];
  994. tmp[1] = ptr[1] + ptr[4];
  995. tmp[2] = ptr[2] + ptr[5];
  996. ptr += xsize*3;
  997. tmp[0] += ptr[0] + ptr[3];
  998. tmp[1] += ptr[1] + ptr[4];
  999. tmp[2] += ptr[2] + ptr[5];
  1000. ptr = simg.getValues(u,v);
  1001. ptr[0] = (tmp[0]+2)>>2;
  1002. ptr[1] = (tmp[1]+2)>>2;
  1003. ptr[2] = (tmp[2]+2)>>2;
  1004.       }
  1005.     }
  1006.   } else if (dim == 2) {
  1007.     for (v=0,y=0; v<sy; v++, y+=2) {
  1008.       for (u=0,x=0; u<sx; u++, x+=2) {
  1009. ptr = at(x,y);
  1010. tmp[0] = ptr[0] + ptr[2];
  1011. tmp[1] = ptr[1] + ptr[3];
  1012. ptr += xsize*2;
  1013. tmp[0] += ptr[0] + ptr[2];
  1014. tmp[1] += ptr[1] + ptr[3];
  1015. ptr = simg.getValues(u,v);
  1016. ptr[0] = (tmp[0]+2)>>2;
  1017. ptr[1] = (tmp[1]+2)>>2;
  1018.       }
  1019.     }
  1020.   } else {
  1021.     for (v=0,y=0; v<sy; v++, y+=2) {
  1022.       for (u=0,x=0; u<sx; u++, x+=2) {
  1023. ptr = at(x,y);
  1024. tmp[0] = ptr[0] + ptr[1];
  1025. ptr += xsize;
  1026. tmp[0] += ptr[0] + ptr[1];
  1027. ptr = simg.getValues(u,v);
  1028. ptr[0] = (tmp[0]+2)>>2;
  1029.       }
  1030.     }
  1031.   }
  1032. }
  1035. // return an image warped by the projective transformation
  1036. // [x' y' w'] = [u v w] M
  1037. Image
  1038. Image::warp(float m[3][3]) const
  1039. {
  1040.   // first, invert the matrix by taking its adjoint
  1041.   // works because it's a projection, scale invariant
  1042.   float Mi[3][3];
  1043.   Mi[0][0] = m[1][1]*m[2][2] - m[1][2]*m[2][1];
  1044.   Mi[0][1] = m[0][2]*m[2][1] - m[0][1]*m[2][2];
  1045.   Mi[0][2] = m[0][1]*m[1][2] - m[0][2]*m[1][1];
  1046.   Mi[1][0] = m[1][2]*m[2][0] - m[1][0]*m[2][2];
  1047.   Mi[1][1] = m[0][0]*m[2][2] - m[0][2]*m[2][0];
  1048.   Mi[1][2] = m[0][2]*m[1][0] - m[0][0]*m[1][2];
  1049.   Mi[2][0] = m[1][0]*m[2][1] - m[1][1]*m[2][0];
  1050.   Mi[2][1] = m[0][1]*m[2][0] - m[0][0]*m[2][1];
  1051.   Mi[2][2] = m[0][0]*m[1][1] - m[0][1]*m[1][0];
  1052.   
  1053.   Image im(xsize, ysize, dim);
  1054.   int tmp[4], cnt;
  1055.   float x,y;
  1056.   uchar *val;
  1058.   for (int v=0; v<ysize; v++) {
  1059.     for (int u=0; u<xsize; u++) {
  1060.       tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
  1061.       cnt = 0;
  1062.       for (int i=0; i<=2; i++) {
  1063. for (int j=0; j<=2; j++) {
  1064.   float ui = u+i/3.0+1./6.;
  1065.   float vj = v+j/3.0+1./6.;
  1066.   float w = 1.0f / (ui*Mi[0][2] + vj*Mi[1][2] + Mi[2][2]);
  1067.   x = (ui*Mi[0][0] + vj*Mi[1][0] + Mi[2][0]) * w;
  1068.   y = (ui*Mi[0][1] + vj*Mi[1][1] + Mi[2][1]) * w;
  1069.   if (x < 0.0 || y < 0.0 || x >= xsize || y >= ysize)
  1070.     continue;
  1071.   cnt++;
  1072.   val = at(x,y);
  1073.   for (int d=0; d<dim; d++) 
  1074.     tmp[d] += int(val[d]);
  1075. }
  1076.       }
  1077.       val = im.getValues(u,v);
  1078.       for (int d=0; d<dim; d++) 
  1079. val[d] = (cnt ? tmp[d] / float(cnt) : 0);
  1080.     }
  1081.   }
  1082.   return im;
  1083. }
  1085. Image 
  1086. Image::crop(int x, int y, int dx, int dy)
  1087. {
  1088.   Image im(dx,dy,dim);
  1089.   for (int v=0; v<dy; v++) {
  1090.     uchar *tmpo = getValues(x,y+v);
  1091.     uchar *tmpn = im.getValues(0,v);
  1092.     for (int i=0; i<dx*dim; i++) {
  1093.       tmpn[i] = tmpo[i];
  1094.     }
  1095.   }
  1096.   return im;
  1097. }
  1099. Image&
  1100. Image::fill(uchar a, uchar b, uchar c, uchar d)
  1101. {
  1102.   int size = xsize*ysize;
  1103.   for (int i=0; i<size; i++) {
  1104.     uchar *tmp = &_data[i*dim];
  1105.     if (dim == 4) tmp[3] = d;
  1106.     if (dim >= 3) tmp[2] = c;
  1107.     if (dim >= 2) tmp[1] = b;
  1108.     if (dim >= 1) tmp[0] = a;
  1109.   }
  1110.   return *this;
  1111. }