tt.cpp

it will work it is recogntion code only

//Copyright(c)2004  Alexander Kadyrov

#define USEPEANO // this line can be commented
                 // USEPEANO provides Peano indexing of images to speed up
                 // the Trace Transform. For some (small?) sizes it is not helpful 
//#define ROTATING_BOX // this line can be commented
                 //Rotating box provides tracing lines of the same length
                 //It can be useful for affine texture recognition
                 //   and Trace Transform in windows (ie. filtering)
                 // Until now (2004) no papers published using ROTATING_BOX
 
#include "unit2.h"
//#include "Peano.h" //int const maxSize=512;///??? solve this later
#include "lines3h.h" // lines3h.h instead of lines2h.h due to Peano coding
#include "objects0.h"
//#include <Vector>
#include <algorithm>
double debug;
// User defined list of images:
int LimList=0;char**imList;
// User defined lists of functionals:
int LtrList=0,*trList,LdiList=0,*diList,LcirList=0,*cirList;
#include "stages0.h"

using namespace std;

 int Verbose,Silent;

int main(int argc, char *argv[ ] ){
//////****************** Sparse:  Analysis of arguments
 int i,i0; 
char*minus_S="-S";//Silent
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_S))break;
 if (i0 EQ argc) Silent=0; else Silent=1;
char*minus_V="-V";//Verbous 
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_V))break;
 if (i0 EQ argc) Verbose=0; else Verbose=1;

#ifdef ROTATING_BOX
  if (!Silent) PS("ROTATING_BOX")
#endif
#ifdef USEPEANO
  if (!Silent) PS("USEPEANO")
#endif


char*Ipath;
char*minusIpath="-Ipath";// path to images
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusIpath))break;
 if(i0<argc-1) Ipath=argv[i0+1]; else Ipath="";

char*Dir;
char*minusDir="-Dir";// path to images
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusDir))break;
 if(i0<argc-1) Dir=argv[i0+1]; else Dir="Outinfo/";
if (!Silent) PV(Dir);

 char*minusIfile="-Ifile";// a list of names of images in a file
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusIfile))break;
 if(i0<argc-1)
 {
 i=i0+1; FILE *Ifile,*imfile; 
 LimList=0;
 char line[100]; 

if( (Ifile  = fopen( argv[i], "r" )) == NULL ) 
  {printf("\n\7 ??? Ifile '%s' was not opened\n",argv[i] );exit(1);} 
  while(!feof(Ifile)) {
        //fgets(line,100,Ifile);
        fscanf(Ifile,"%[^\n]\n",line);
        sscanf(line,"%s",line);
     LimList++;} 
  fclose(Ifile);
 
imList=new char*[LimList];
 if( (Ifile  = fopen( argv[i], "r" )) == NULL ) 
  {printf("\n\7 ??? Ifile '%s' was not opened\n",argv[i] );exit(1);} 
  int j=0;
  while(!feof(Ifile)) {
        //fgets(line,100,Ifile);
        fscanf(Ifile,"%[^\n]\n",line);
        sscanf(line,"%s",line);
        imList[j]=concat("",line);
           if( (imfile  = fopen(concat(Ipath,imList[j]), "r" )) == NULL )
  {printf("\n\7 ??? image file '%s' listed in '%s' was not opened\n",imList[j],argv[i]);exit(1);}
           fclose(imfile); // to be sure that image files exist (before computations)
     j++;} 
  fclose(Ifile);
  }
else
  {
 char*minusI="-I";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusI))break;
 LimList=0;
 for(i=i0+1;i<argc;i++) if(argv[i][0] != '-') LimList++; else break;
 imList=new char*[LimList];
 for(i=i0+1;i<=i0+LimList;i++) imList[i-i0-1]=argv[i];
  }

if (!Silent) NPV(LimList) if (!Silent) PV(Ipath) PN;
if ((!Silent && LimList<6) || Verbose) 
 for(i=0;i<LimList;i++)printf("image no.%d  %s\n",i,imList[i]);
 
 char*minusT="-T";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusT))break;
 LtrList=0;
 for(i=i0+1;i<argc;i++) if(argv[i][0] != '-') LtrList++; else break;
 trList=new int[LtrList];
 for(i=i0+1;i<=i0+LtrList;i++) trList[i-i0-1]=atoi(argv[i]);
 
 if (!Silent){PS(" -T : ")PV(LtrList)PA(trList,0,LtrList-1)}

 char*minusP="-P";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusP))break;
 LdiList=0;
 for(i=i0+1;i<argc;i++) if(argv[i][0] != '-') LdiList++; else break;
 diList=new int[LdiList];
 for(i=i0+1;i<=i0+LdiList;i++) diList[i-i0-1]=atoi(argv[i]);
 
if (!Silent){PS(" -P : ")PV(LdiList)PA(diList,0,LdiList-1)}
  
 char*minusF="-F";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minusF))break;
 LcirList=0;
 for(i=i0+1;i<argc;i++) if(argv[i][0] != '-') LcirList++; else break;
 cirList=new int[LcirList];
 for(i=i0+1;i<=i0+LcirList;i++) cirList[i-i0-1]=atoi(argv[i]);

if (!Silent){PS(" -F : ")PV(LcirList)PA(cirList,0,LcirList-1)} 


double dt,dp; //int *ret2DCut=new int[128*128]; 
 char*minus_dt="-dt";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_dt))break;
 if (i0 >= argc-1) dt=1.0; else dt=atof(argv[i0+1]);
 char*minus_dp="-dp";
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_dp))break;
 if (i0 >= argc-1) dp=1.0; else dp=atof(argv[i0+1]);
 char*minus_360="-360";
 int user360;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_360))break;
 if (i0 >= argc-1) user360=128; else user360=atoi(argv[i0+1]);
 int Nfi4=  (user360+3) / 4;

if (!Silent) {PV(dt) PV(dp) PVN(Nfi4)}
////  options for writing Trace matrices:
 char*minus_wTtxt="-wTtxt";//write Trace Matrix in .txt double for matlab's textread.m
 int wTtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wTtxt))break;
 if (i0 EQ argc) wTtxt=0; else wTtxt=1;
if (!Silent & wTtxt)PV(wTtxt)
 char*minus_wTpgm="-wTpgm";//write Trace Matrix in .pgm for matlab's textread.m
 int wTpgm; unsigned char*Mpgm=NULL; int LMpgm=0;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wTpgm))break;
 if (i0 EQ argc) wTpgm=0; else wTpgm=1;
if (!Silent & wTpgm)PV(wTpgm) 

 char*minus_wT="-wT";//write Trace Matrix in .sm ("small" format) for matlab's textread.m
 int wT;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wT))break;
 if (i0 EQ argc) wT=0; else wT=1;
if (!Silent & wT)PV(wT)
////  options for writing plain circuses:
 char*minus_wCtxt="-wCtxt";//write circuses in files .txt for matlab's textread.m
 int wCtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wCtxt))break;
 if (i0 EQ argc) wCtxt=0; else wCtxt=1;
if (!Silent & wCtxt)PV(wCtxt)

 char*minus_iwCtxt="-iwCtxt";//write circuses in one .txt for matlab's textread.m
 int iwCtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwCtxt))break;
 if (i0 EQ argc) iwCtxt=0; else iwCtxt=1;
if (!Silent & iwCtxt)PV(iwCtxt)
 char*minus_wC="-wC";
 int wC;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wC))break;
 if (i0 EQ argc) wC=0; else wC=1;
if (!Silent & wC)PV(wC)
 char*minus_iwC="-iwC";
 int iwC;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwC))break;
 if (i0 EQ argc) iwC=0; else iwC=1;
if (!Silent & iwC)PV(iwC)
////  options for writing normalised associated circuses:
 char*minus_wCAtxt="-wCAtxt";//write circuses in files .txt for matlab's textread.m
 int wCAtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wCAtxt))break;
 if (i0 EQ argc) wCAtxt=0; else wCAtxt=1;
if (!Silent & wCAtxt)PV(wCAtxt)
 char*minus_iwCAtxt="-iwCAtxt";//write circuses in one .txt for matlab's textread.m
 int iwCAtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwCAtxt))break;
 if (i0 EQ argc) iwCAtxt=0; else iwCAtxt=1;
if (!Silent & iwCAtxt)PV(iwCAtxt)
 char*minus_wCA="-wCA";
 int wCA;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wCA))break;
 if (i0 EQ argc) wCA=0; else wCA=1;
if (!Silent & wCA)PV(wCA)
 char*minus_iwCA="-iwCA";
 int iwCA;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwCA))break;
 if (i0 EQ argc) iwCA=0; else iwCA=1;
if (!Silent & iwCA)PV(iwCA)
////  options for writing normalised plain circuses:
 char*minus_wCPtxt="-wCPtxt";//write circuses in files .txt for matlab's textread.m
 int wCPtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wCPtxt))break;
 if (i0 EQ argc) wCPtxt=0; else wCPtxt=1;
if (!Silent & wCPtxt)PV(wCPtxt)
 char*minus_iwCPtxt="-iwCPtxt";//write circuses in one .txt for matlab's textread.m
 int iwCPtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwCPtxt))break;
 if (i0 EQ argc) iwCPtxt=0; else iwCPtxt=1;
if (!Silent & iwCPtxt)PV(iwCPtxt)
 char*minus_wCP="-wCP";
 int wCP;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_wCP))break;
 if (i0 EQ argc) wCP=0; else wCP=1;
if (!Silent & wCP)PV(wCP)
 char*minus_iwCP="-iwCP";
 int iwCP;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwCP))break;
 if (i0 EQ argc) iwCP=0; else iwCP=1;
if (!Silent & iwCP)PV(iwCP)
////  options for writing triple features
 char*minus_iwFtxt="-iwFtxt";
 int iwFtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwFtxt))break;
 if (i0 EQ argc) iwFtxt=0; else iwFtxt=1;
if (!Silent & iwFtxt)PV(iwFtxt)
 char*minus_iwF="-iwF";//currently is not used ????
 int iwF;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwF))break;
 if (i0 EQ argc) iwF=0; else iwF=1;
if (!Silent & iwF)PV(iwF)
char*minus_iwFAtxt="-iwFAtxt";
 int iwFAtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwFAtxt))break;
 if (i0 EQ argc) iwFAtxt=0; else iwFAtxt=1;
if (!Silent & iwFAtxt)PV(iwFAtxt)
 char*minus_iwFA="-iwFA";//currently is not used ????
 int iwFA;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwFA))break;
 if (i0 EQ argc) iwFA=0; else iwFA=1;
if (!Silent & iwFA)PV(iwFA)
char*minus_iwFPtxt="-iwFPtxt";
 int iwFPtxt;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwFPtxt))break;
 if (i0 EQ argc) iwFPtxt=0; else iwFPtxt=1;
if (!Silent & iwFPtxt)PV(iwFPtxt)
 char*minus_iwFP="-iwFP";//currently is not used ????
 int iwFP;
 for(i0=0;i0<argc;i0++) if (strCompare(argv[i0],minus_iwFP))break;
 if (i0 EQ argc) iwFP=0; else iwFP=1;
if (!Silent & iwFP)PV(iwFP)
// to do : verbose 
///  text file for latest data of functionals : L lists 

/////{for(int i=0;i<argc;i++) {NPV(i) PV(argv[i])};}  //???
//////****************** Sparse END 


int computeNormalisedCircusesA=wCAtxt+iwCAtxt+ wCA+ iwCA +
                            iwFAtxt+iwFA;
int computeNormalisedCircusesP=
                            wCPtxt+iwCPtxt+ wCP+ iwCP+
                            iwFPtxt+iwFP;
int computeNormalisors=computeNormalisedCircusesA+
                       computeNormalisedCircusesP;

attFill();
{using namespace TRACE; 
  UfVArrAssign();fillcomputedby();//attFill();fillcomputedby(); are filled forever
} // - order!
int rSize0=1; unsigned char*retina=new unsigned char[rSize0];
int xSize,ySize,max2Size0=1;
int *dilute0=new int[max2Size0],*dilute=new int[max2Size0];
unsigned char*Peanoretina=new unsigned char[max2Size0*max2Size0];
int*Ends=new int[1];int xSize0=0,ySize0=0;
{using namespace TRACE; stagetraceBegin();dlt=dt;make_oaKcorr();}
 N2pi=4*Nfi4; Npi=2*Nfi4;
{using namespace DIAM;  stagediam();dlt=dp;make_oaKcorr();}//-prepare room for circuses. This need N2pi
{using namespace TRIPLE;  stagetriple();dlt=pi2/N2pi;make_oaKcorr();}//-prepare room for triple features. This need N2pi

int Lt=TRACE::LlistU,Ld=DIAM::LlistU,Lc= Lt*Ld,Lf=TRIPLE::LlistU,Ltf=Lt*Ld*Lf;

int Stages=0; if(Lt){Stages++;if(Ld){Stages++;if(Lf)Stages++;}}//0,1,2,or 3 stages
if (!Silent) printf("\nThe program proceeds %d stage(s) from TRACE,DIAM,TRIPLE\n",Stages);
/// writng file   functionalsList.txt
 FILE *fl;char*functionalsList=concat(Dir,"functionalsList.txt");
  if( (fl  = fopen(functionalsList,"w")) == NULL ) 
  {printf("\n\7 ???File '%s' was not opened for writing\n",functionalsList);exit(1);}  
  fprintf(fl," %d %d %d %d %d",Stages,Lt,Ld,Lf,N2pi);
  //fprintf(fl," %s "," these are: Stages,Lt,Ld,Lf,N2pi");
  {int i;for(i=0;i<Lt;i++) fprintf(fl," %d",TRACE::listU[i]);
         for(i=0;i<Ld;i++) fprintf(fl," %d",DIAM::listU[i]);
         for(i=0;i<Lf;i++) fprintf(fl," %d",TRIPLE::listU[i]);
      //??????? UNCOMMENT THIS LATER !!!!!
  }
  fclose(fl);



int *circIsUomega;double *circUomega;
int *circAuthorNormalisor;//can it generate standard affine normalisor?
if (Lc)
{ circIsUomega=new int[Lc];circUomega=new double[Lc];circAuthorNormalisor=new int[Lc];
  for(int nf=0;nf<Lt;nf++)
     {  int tfnl=TRACE::listU[nf];
        for (int cf=0;cf<DIAM::LlistU;cf++)
        { int cfnl=DIAM::listU[cf]; int rem=
          circIsUomega[Ld*nf+cf]=attHasLambda[tfnl] && attHasKappa[cfnl] && attHasLambda[cfnl];
          if(rem)
            {circUomega[Ld*nf+cf]=attLambda[cfnl] * attKappa[tfnl] - attLambda[cfnl];
             if (abs(circUomega[Ld*nf+cf])<0.00001)circUomega[Ld*nf+cf]=0; 
            }
          else circUomega[Ld*nf+cf]=0;
          circAuthorNormalisor[Ld*nf+cf]=
                    (attKind[tfnl] EQ 1)&&(attKind[cfnl] EQ 1)&&circIsUomega[Ld*nf+cf];
                    // both are invariant and uomega exist - 
                    //               my current assumption
        }  
     }             
} 
if(Verbose){PN;PA(circIsUomega,0,Lc-1);PA(circUomega,0,Lc-1);
               PA(circAuthorNormalisor,0,Lc-1);}

double *NormMaxAngle,*NormBeta; 
if (computeNormalisors){ NormMaxAngle=new double[Lt*Ld];NormBeta=new double[Lt*Ld];}

// working with a picture
///********************************THE BIG IMAGE LOOP*********************///
int imNo; char*DirTrMatrs=concat(Dir,"TrMatrs/");
          char*DirCircuses=concat(Dir,"Circuses/");
          char*DirTriple=concat(Dir,"Triple/");

{for (imNo=0;imNo<LimList;imNo++){  //THE BIG IMAGE LOOP
if(Verbose){timer1start(); timer2start();}
char*fullname=imList[imNo]; char*nameNE=removeExtention(fullname);
                            char*nameNE_T=concat(nameNE,"T");
if(Verbose)printf("\n*****Working with image no.%d '%s'\n",imNo,fullname);
     //unsigned char*retina=pgmRead(concat(Ipath,fullname),&xSize,&ySize);
     retina=pgmRead0(rSize0,retina,concat(Ipath,fullname),&xSize,&ySize);

int rSize=xSize*ySize; 
  if(Verbose){PV(xSize)PV(ySize)}

#ifdef  USEPEANO  //////////////////////PEANO STARTS
int maxSize=maxI(xSize,ySize);
int deg=int(ceil(-0.0001+log(maxSize)/log(2))); //PVN(deg);
int max2Size=1<<deg; 
if (max2Size>max2Size0)
 {delete[]dilute0;dilute0=new int[max2Size];
  delete[]dilute;dilute=new int[max2Size];
  delete[]Peanoretina;Peanoretina=new unsigned char[max2Size*max2Size];

   for(int i=0;i<max2Size;i++)
    {int iD=0; 
       for(int d=0;d<deg;d++) iD+=((1<<d)&i)<<d;
       //dilute[i]=iD;dilute0[i]=( unsigned short)(iD<<1);
       dilute[i]=iD;dilute0[i]=iD<<1;
    }
  max2Size0=max2Size;