home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / analysis.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  8.6 KB  |  258 lines
  1. #include "includes.h"
  2.  
  3. /**************************************|****************************************
  4. Routine   : CountType
  5. Input  par: Transformation *T (pointer to trans)
  6.             int type          (type to be counted)
  7. Output par: int               (counts)
  8. Function  : counts main-block and its subblocs of type 'type'. Does the counting
  9.             recursivly. 
  10. ***************************************|***************************************/
  11.  
  12.  unsigned long CountType(Transformation *T, int type)
  13.   {
  14.    unsigned long count=0,i,j;
  15.    
  16.    if (T->Type==type) count++;
  17.    if (T->Sub!=NULL)
  18.     {
  19.      for(i=0;i<2;i++)
  20.      for(j=0;j<2;j++)
  21.      if (T->Sub[i][j]!=NULL) count += CountType(T->Sub[i][j],type);
  22.     }
  23.    return count;
  24.   }
  25.  
  26. /**************************************|****************************************
  27. Routine   : CountMainSubs
  28. Input  par: Transformation *T (pointer to trans)
  29. Output par: unsigned int (counted mainsub configurations)
  30. Function  : counts main-sub-configurations recursively.
  31. ***************************************|***************************************/
  32.  
  33.  unsigned long CountMainSubs(Transformation *T,unsigned long *PureMain,int level)
  34.   {
  35.    unsigned long count=1,i,j;   
  36.  
  37.    if (T->Sub!=NULL)
  38.     {
  39.      for(i=0;i<2;i++)
  40.      for(j=0;j<2;j++)
  41.      if (T->Sub[i][j]!=NULL) 
  42.      { 
  43.        level--;
  44.        count +=  CountMainSubs(T->Sub[i][j],PureMain,level);
  45.       }
  46.     }
  47.    else (PureMain[level])++;
  48.    return count;
  49.   }
  50.  
  51. /**************************************|****************************************
  52. Routine   : HeadInfo
  53. Input  par: Transformation ***T (pointer to trans array)
  54.             LimboHeader *Head   (pointer to header structure)
  55. Output par: none
  56. Function  : Produce info-statistic on Limbo-Header (fractal code header).
  57. ***************************************|***************************************/
  58.  
  59.  void HeadInfo(Transformation ***T, LimboHeader *Head)
  60.   {
  61.    Parameter *Par=GimmeAParameter();
  62.    int i,j,x,y;
  63.    unsigned long edg=0,sha=0,mainsubs=0;
  64.    unsigned long *PureMain;
  65.    
  66.    vprintf(stderr,"\nFractal code info...");
  67.    
  68.    Par->XBits=Head->XBits;
  69.    Par->YBits=Head->YBits;
  70.    
  71.    Par->SBits=Head->SBits;
  72.    Par->ABits=Head->ABits;
  73.    Par->AMax =Head->AMax/100.0;
  74.    Par->AMin =Head->AMin/100.0;
  75.    Par->DBits=Head->DBits;
  76.    Par->GBits=Head->GBits;
  77.    Par->TBits=Head->TBits;
  78.    
  79.    x=Head->MSBx*256+Head->LSBx;
  80.    y=Head->MSBy*256+Head->LSBy;
  81.    
  82.    PureMain=GimmeALongArray(Head->NSquare+1);
  83.    for (i=0;i<Head->NSquare;i++) PureMain[i]=0;
  84.  
  85.    for (i=0;i<x/(Head->B<<Head->NSquare);i++) /* count edges + shades */
  86.    for (j=0;j<y/(Head->B<<Head->NSquare);j++)
  87.     {
  88.      edg += CountType(T[i][j],EDGEBLOCK);
  89.      sha += CountType(T[i][j],SHADEBLOCK);
  90.      mainsubs += CountMainSubs(T[i][j],PureMain,Head->NSquare);
  91.     }
  92.    
  93.     {
  94.      unsigned long he=(sizeof(LimboHeader)+LIMBOSTRINGSIZE)*8;
  95.      unsigned long edgbit=1+Par->XBits+Par->YBits+Par->ABits+Par->DBits+1+Par->TBits;
  96.      unsigned long shabit=1+Par->GBits;
  97.      unsigned long ed=edg*edgbit;
  98.      unsigned long sh=sha*shabit;
  99.      unsigned long to=ed+sh+Par->SBits*mainsubs;
  100.      unsigned long ratio=(x*y*8*100)/to;
  101.      unsigned long SNR=Head->MSBSNR*256+Head->LSBSNR;
  102.      unsigned long cpu=Head->MSBCPU*256+Head->LSBCPU;
  103.      
  104.      vprintf(stderr,"\n   Size:(%d,%d)  Offset:(%d,%d)",x,y,
  105.              Head->MSBox*256+Head->LSBox,Head->MSBoy*256+Head->LSBoy);
  106.      for (i=Head->NSquare;i>=0;i--) 
  107.      vprintf(stderr,"\n   Block size:  Domain:%2d  Range:%2d  Delta:%2d  Pure main blocks:%d ",
  108.              Head->B<<(1+i),Head->B<<i,Head->Delta,PureMain[i]);
  109. /*
  110.      vprintf(stderr,"\n   Type:%d  Colors:%d  KeepDelta:%d ",
  111.              Head->Type,Head->Col,Head->KeepDelta,Head->Type);
  112. */
  113.      vprintf(stderr,"\n   Bits:  X:%d  Y:%d  Sub:%d  Alpha:%d  DeltaG:%d  G0:%d  TN:%d",
  114.              Par->XBits,Par->YBits,Par->SBits,Par->ABits,Par->DBits,
  115.              Par->GBits,Par->TBits);
  116.      vprintf(stderr,"\n   Range:  Alpha max:%1.2f  Alpha min:%1.2f",Par->AMax,Par->AMin);
  117.      vprintf(stderr,"\n   Header:                                         %7d [bit]",he);
  118.      vprintf(stderr,"\n   Mainsub: %9u blocks of size %2u [bit] = %10u [bit]",
  119.              mainsubs,Par->SBits,mainsubs*Par->SBits);
  120.      vprintf(stderr,"\n   Shades:  %9u blocks of size %2u [bit] = %10u [bit]",sha,shabit,sh);
  121.      vprintf(stderr,"\n   Edges:   %9u blocks of size %2u [bit] = %10u [bit]",edg,edgbit,ed);
  122.      vprintf(stderr,"\n   Total:                                           %u [bit] = %u [byte]",
  123.              to+he,(to+he+7)/8);
  124.      vprintf(stderr,"\n   Ratio:   %3.2f:1 = %3.2f%% = %1.3f [bpp]",
  125.              (float)ratio/100.0,10000.0/(float)ratio,(float)to/(float)(x*y));
  126.      vprintf(stderr,"\n   PSNR:    %3.2f [dB]\n   CPU Time:%5u [sec]",(float)SNR/100.0,cpu);
  127.     }
  128.  
  129.    FreeMeAULongArray(PureMain);
  130.   } 
  131.  
  132.  
  133.  void BitMapAnalyze(char *filename, int Iterations)
  134.   {
  135.    int x,y,i,j,B,delta;
  136.    Transformation ***T;
  137.    LimboHeader *Head;
  138.    BitMap *Sha,*Edg,*Blc,*Self,*Tot,*Err,*Org,*Dst,*JPEG,*ErrJPEG;
  139.    char file[99];
  140.    char jpegfilename[MAXFILE];
  141.    FILE *jpeg;
  142.    int jpegfound=TRUE;
  143.  
  144.    Head=LoadFC(&T,filename);    /* header load */
  145.    /*HeadInfo(T,Head);*/
  146.    x=Head->MSBx*256+Head->LSBx;
  147.    y=Head->MSBy*256+Head->LSBy;
  148.    B=Head->B;
  149.    delta=B<<Head->NSquare;
  150.    
  151.    Dst=Decode(T,Head->Type,x,y,Head->B<<Head->NSquare,Iterations,0); /* decoding */
  152.  
  153.    Edg=GimmeABitMap(x,y,GRAYIMG);
  154.    /*CopyBitMap(Dst,Edg); */ Color(Edg,EDGEBLOCK_COLOR); 
  155.    Sha=GimmeABitMap(x,y,GRAYIMG);
  156.    /*CopyBitMap(Dst,Sha); */ Color(Sha,SHADEBLOCK_COLOR);
  157.    Blc=GimmeABitMap(x,y,GRAYIMG);
  158.    /*CopyBitMap(Dst,Blc); */ Color(Blc,255); 
  159.    Self=GimmeABitMap(x,y,GRAYIMG);
  160.    /*CopyBitMap(Dst,Self);*/  Color(Self,EDGEBLOCK_COLOR); 
  161.    
  162.    Tot=GimmeABitMap(x,y,GRAYIMG);
  163.    Color(Tot,255);
  164.    Err=GimmeABitMap(x,y,GRAYIMG);
  165.    ErrJPEG=GimmeABitMap(x,y,GRAYIMG);
  166.    
  167.    Org=LoadBitMap(filename,x,y,0,0,delta<<1,""); /* load orginal bitmap image */
  168.  
  169.  
  170.    strcpy(jpegfilename,ORGGFX);   /* test the existence of a encoded/decoded jpeg */
  171.    strcat(jpegfilename,filename); /* bitmap in pgm/ppm format */
  172.    strcat(jpegfilename,".jpg");
  173.    vprintf(stderr,"\n   Searching for JPEG file '%s'...",jpegfilename);
  174.    if (!(jpeg=fopen(jpegfilename,"rb"))) /* first try no suffix */
  175.     {
  176.      strcat(jpegfilename,PPMSFX);  /* try ppm */
  177.      if (!(jpeg=fopen(jpegfilename,"rb")))   
  178.       {
  179.        strcpy(jpegfilename,ORGGFX);
  180.        strcat(jpegfilename,file);
  181.        strcat(jpegfilename,PGMSFX); /* try pgm then */
  182.        if (!(jpeg=fopen(jpegfilename,"rb"))) jpegfound=FALSE;
  183.       }
  184.     }
  185.    
  186.    if (jpegfound) 
  187.     {
  188.      vprintf(stderr," found");
  189.      fclose(jpeg);
  190.      strcpy(jpegfilename,filename); /* bitmap in pgm/ppm format */
  191.      strcat(jpegfilename,".jpg");
  192.    
  193.      JPEG=LoadBitMap(jpegfilename,x,y,0,0,1,"");
  194.      vprintf(stderr,"\n   Orginal image/JPEG PSNR:%3.2f",PSNR(Org,JPEG));
  195.  
  196.      for(i=0;i<x;i++)   /* build error image  error = 5*(a-b)^2  or 5*abs(a-b) */ 
  197.      {
  198.       for(j=0;j<y;j++) 
  199.        {
  200.         float temp=Org->Map[i][j]-JPEG->Map[i][j];
  201.           /* temp = 5.0*temp*temp; or*/ temp = 5*abs(temp);
  202.         RectFill(ErrJPEG,i,j,1,1,(unsigned int)temp);
  203.        }
  204.      }
  205.    }
  206.   else vprintf(stderr," not found");
  207.    
  208.    for(i=0;i<x;i++)   /* build error image  error = 5*(a-b)^2  or 5*abs(a-b) */ 
  209.     {
  210.      for(j=0;j<y;j++) 
  211.       {
  212.        float temp=Org->Map[i][j]-Dst->Map[i][j];
  213.          /* temp = 5.0*temp*temp; or*/ temp = 5*abs(temp);
  214.        RectFill(Err,i,j,1,1,(unsigned int)temp);
  215.       }
  216.     }
  217.    vprintf(stderr,"\nPSNR=%3.2f [dB]",PSNR(Org,Dst));
  218.    
  219.    for(i=0;i<x;i+=delta) /* build shade, edge blocks in bitmap */
  220.     {
  221.      for(j=0;j<y;j+=delta)
  222.       {
  223.        RecursiveRect(T[i/delta][j/delta],Sha,i,j,SHADEBLOCK,0);
  224.        RecursiveRect(T[i/delta][j/delta],Edg,i,j,EDGEBLOCK,0);
  225.        
  226.        RecursiveRect(T[i/delta][j/delta],Blc,i,j,SHADEBLOCK,0);
  227.        RecursiveRect(T[i/delta][j/delta],Blc,i,j,EDGEBLOCK,0);
  228.        
  229.        RecursiveRect(T[i/delta][j/delta],Tot,i,j,SHADEBLOCK,0);
  230.        RecursiveRect(T[i/delta][j/delta],Tot,i,j,EDGEBLOCK,0);
  231.        
  232. /*       RecursiveSelfTransArrow(T[i/delta][j/delta],Self,i,j,EDGEBLOCK,-1);*/
  233.       }
  234.     }
  235.    
  236.    /* save all bitmaps */
  237.    strcpy(file,filename);
  238.    strcat(file,"_sha");
  239.    SaveAndView(file,Sha);
  240.    strcpy(file,filename);
  241.    strcat(file,"_edg");
  242.    SaveAndView(file,Edg);
  243.    strcpy(file,filename);
  244.    strcat(file,"_blc");
  245.    SaveAndView(file,Blc);
  246.    strcpy(file,filename);
  247.    strcat(file,"_tot");
  248.    SaveAndView(file,Tot);
  249.    strcpy(file,filename);
  250.    strcat(file,"_err");
  251.    SaveAndView(file,Err);
  252.    strcpy(file,filename);
  253.    strcat(file,"_errjpeg");
  254.    SaveAndView(file,ErrJPEG);
  255.    strcpy(file,filename);
  256.    strcat(file,"_self");
  257.    SaveAndView(file,Self);
  258.   }