modioperandi0.h

基于＂trace transform＂的识别２Ｄ图像的Ｃ＋＋源程序

  out wei_threshold=weight/2, cumsum=0; sctr1=sctr+c;
  //Zerofy outmedtemp:
  if (IS_sortedRLsctr34)
   for (j=0;j<Lr34;j++) outmedtemp[sortedRLsctr34[j]]=0;
  else
   for (i=Max;i>=0;i--) outmedtemp[i]=0;
  //Collect weights there:
  tr1=atr+c;
  for (j=Lr34-1;j>=0;j--) {i=sctr1[j];outmedtemp[i]+= tr1[j] * j ;}
  //Find median:
  if (IS_sortedRLsctr34)
   { int i0=-1;
     for (j=0;j<Lr34;j++)
          {i=sortedRLsctr34[j];
           if (i>i0)
            {i0=i;cumsum+=outmedtemp[i];if (cumsum>wei_threshold) break;}
          }
   }   
  else
   for (i=0;i<=Max;i++) {cumsum+=outmedtemp[i];if (cumsum>wei_threshold) break;}
  
  int med=i;
#if typetr //int and double, rescale "med" back:       i
       double Coe=(double)Max / max_min;
    o[58] = med/Coe+min;
#else
    o[58] = med;
#endif
}//END
void V69(void)
{v[0]=58;v[1]=0;v[2]=0;v[3]=0;}//computed objects,line should end with zero 
//*******************ANOTHER MODUS OPERANDI 
void U70(void){u[0]=54;u[1]=6;u[2]=0;u[3]=0;}//uses objects,line should end with zero 
void f70(void)//object 59=back58 "MedianW R+: f(t-c); c is median abscissa (34);\n   W=abs(f(t))(t-c)"
{ out weight=0;int c=medindex-lbeg;tr1=atr+c; 
  {for(int j=0;j<Ll34;j++)weight += (*tr1--) * j;}
  if (weight EQ 0) 
  { o[59]=tr[c] ;return;}

  int i,j;  
  out wei_threshold=weight/2, cumsum=0; sctr1=sctr+c;
                           int*sL=sortedRLsctr34+Lr34;
  //Zerofy outmedtemp:
  if (IS_sortedRLsctr34)
   for (j=0;j<Ll34;j++) outmedtemp[sL[j]]=0;
  else
   for (i=Max;i>=0;i--) outmedtemp[i]=0;
  //Collect weights there:
   tr1=atr+c;
   for (j=0;j<Ll34;j++) {i=*sctr1--;outmedtemp[i]+= *tr1-- * j ;}
  //Find median:
  if (IS_sortedRLsctr34)
   { int i0=-1;
     for (j=0;j<Ll34;j++)
          {i=sL[j];
           if (i>i0)
            {i0=i;cumsum+=outmedtemp[i];if (cumsum>wei_threshold) break;}
          }
   }   
  else
   for (i=0;i<=Max;i++) {cumsum+=outmedtemp[i];if (cumsum>wei_threshold) break;}
  
  int med=i;
#if typetr //int and double, rescale "med" back:       i
       double Coe=(double)Max / max_min;
    o[59] = med/Coe+min;
#else
    o[59] = med;
#endif
}//END
void V70(void)
{v[0]=59;v[1]=0;v[2]=0;v[3]=0;}//computed objects,line should end with zero 
//*******************ANOTHER MODUS OPERANDI
void U71(void){u[0]=59;u[1]=0;u[2]=0;u[3]=0;}//uses objects,line should end with zero 
               // all objects are already booked by object 55
void f71(void)
{   o[60]=-o[59]; 
}//END.
void V71(void)
{v[0]=60;v[1]=0;v[2]=0;v[3]=0;}//computed objects,line should end with zero 
//*******************ANOTHER MODUS OPERANDI


////"MedianW R+: f(x-c); c is median abscissa (34);\n   W=sqrt(abs(f(t);"
/* int c= (int) ceil(medindex-lbeg), i;
       double wei_threshold_2=0;
       for (i=c;i<=fin;i++) wei_threshold_2+=weights_sqrt_sctr[i];
       double wei_threshold=wei_threshold_2/2;
//medRight1=medianW(fin-c+1,sctr+c,Max,weights_sqrt_sctr+c,wei_threshold,medtemp);
  
    o[55]=wei_threshold;
*/
    //o[55]=medRight1;// ????? rescaling back !!! 




//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
/*void U??(void){u[0]=0;u[1]=0;u[2]=0;u[3]=0;}//uses objects,line should end with zero 
void f??(void)
    { ...
    o[ob]=...; 
    }//END.
void V??(void)
{v[0]=ob;v[1]=0;v[2]=0;v[3]=0;}//computed objects,line should end with zero 
*/
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************ANOTHER MODUS OPERANDI
//*******************================================END of MODI OPERANDI
void UfVArrAssign(void)       //PLACE2 
{int M; for (M=0;M<Amount;M++) {U[M]=NULL;f[M]=NULL;V[M]=NULL;} 
  M=2;U[M]= &U2;f[M]= &f2;V[M]= &V2;
  M=4;U[M]= &U4;f[M]= &f4;V[M]= &V4;
  M=6;U[M]= &U6;f[M]= &f6;V[M]= &V6;//computes object 6 "abs trace"
 M=40;U[M]=&U40;f[M]=&f40;V[M]=&V40;
 M=41;U[M]=&U41;f[M]=&f41;V[M]=&V41;
 M=44;U[M]=&U44;f[M]=&f44;V[M]=&V44;
 M=46;U[M]=&U46;f[M]=&f46;V[M]=&V46;
 M=47;U[M]=&U47;f[M]=&f47;V[M]=&V47;
 M=48;U[M]=&U48;f[M]=&f48;V[M]=&V48;
 M=50;U[M]=&U50;f[M]=&f50;V[M]=&V50;
 M=54;U[M]=&U54;f[M]=&f54;V[M]=&V54;
 M=55;U[M]=&U55;f[M]=&f55;V[M]=&V55;//computes object 44 "differences 1"
 M=56;U[M]=&U56;f[M]=&f56;V[M]=&V56;//computes object 45 "integral of |tr'|   "
 M=57;U[M]=&U57;f[M]=&f57;V[M]=&V57;//computes object 45 "integral of |tr'| circular"
 M=58;U[M]=&U58;f[M]=&f58;V[M]=&V58;//computes object 44 "differences 2"
 M=59;U[M]=&U59;f[M]=&f59;V[M]=&V59;//computes object 45 "integral of |tr''|   "
 M=60;U[M]=&U60;f[M]=&f60;V[M]=&V60;//computes object 45 "integral of |tr''| circular"
 M=61;U[M]=&U61;f[M]=&f61;V[M]=&V61;//computes object 50 "t - gravity center of abs(f(t))"
 M=62;U[M]=&U62;f[M]=&f62;V[M]=&V62;//computes object 51 "Lp quasi-norm (p=0.5) = (sumSqR)^2, where sumSqR=integral sqrt(abs(f(t))"; 
 M=63;U[M]=&U63;f[M]=&f63;V[M]=&V63;//computes object 52 "t median index dividing integral sqrt(abs(f(t)))"
 M=64;U[M]=&U64;f[M]=&f64;V[M]=&V64;//object 53 "Scaled abs trace"
 
 M=65;U[M]=&U65;f[M]=&f65;V[M]=&V65;//object 
 M=66;U[M]=&U66;f[M]=&f66;V[M]=&V66;//object 
 M=67;U[M]=&U67;f[M]=&f67;V[M]=&V67;//object 
 M=68;U[M]=&U68;f[M]=&f68;V[M]=&V68;//object 

M=69;U[M]=&U69;f[M]=&f69;V[M]=&V69;//object 58
M=70;U[M]=&U70;f[M]=&f70;V[M]=&V70;//object 59
M=71;U[M]=&U71;f[M]=&f71;V[M]=&V71;//object 60


}
/////////////// Memory for bigger helping objects (if the object is a set of numbers)
int ML;//maximal posible length of any track, used in objectsMemoryConstructor
unsigned char oneeded[Amount];//-binary; marks of those objects which are going to be computed, even if the user did not ask for all of them
                          // however this may not counside with user's choice.

void objectsMemoryConstructor(void)   //PLACE3
{static int MML;//initialises to 0 at the first call
  // oneeded is fixed for the whole STAGE. 
  //If a new bigger ML comes, then needed memory reallocated  
 int e=(MML<ML); if (!e) return;

 //Absolute (ie for many purposes):==================
  int LSQRT16=256;if (LSQRT16<ML) LSQRT16=ML;
  delete[]SQRT16;SQRT16 = new int[LSQRT16];   
  for(int i=0;i<256;i++)SQRT16[i]=(int)(sqrt(i)*16);

  delete[]sortfeed;sortfeed=new int[ML];
  delete[]sorttemp;sorttemp=new int[2*ML];


 //Relative:=========================================

 if (oneeded[3]){delete[]br;br=new TYPEtr[ML];}//back (ie inverse) track
 if (oneeded[5]){delete[]sr;sr=new TYPEsr[ML];}//signed back track
 if (oneeded[6])if(typetr>0){delete[]atr;atr=new TYPEtr[ML];}
 if (oneeded[44]){delete[]diff1;diff1=new TYPEsr[ML];
                  delete[]adiff1;adiff1=new TYPEsr[ML];}//"differences 1"
 if (oneeded[47]){delete[]diff2;diff2=new TYPEsr[ML];
                  delete[]adiff2;adiff2=new TYPEsr[ML];}//"differences 2"
 if (oneeded[53]){delete[]sctr;sctr=new unsigned char[ML];}//Scaled trace
 if (oneeded[54]){delete[]sortedRLsctr34;sortedRLsctr34=new int[ML+2];}//Scaled abs trace


/* 


if (oneeded[54]){delete[]weights_sqrt_sctr;weights_sqrt_sctr=new double[ML];
                  if (SQRT EQ NULL)
                   {SQRT=new double[256];for(int i=0;i<256;i++)SQRT[i]=sqrt(i);}
                 }//object 54 "Weight sqrt(sctr)"
 if (oneeded[55]){delete[]medtemp;medtemp=new double[ML];}//
*/


////////////////////////////
 MML=ML;
}//END.  
 
////*******************************************************
void fillcomputedby(void)//initialisation of "computedby",it is out of the namespaces
                         // Once enough, for example, at TRACE stage
{ int M,k,vk;
  for(M=2;M<Amount;M++)if(f[M] != NULL)//Next line:Logical "==" is used only as macros "EQ" in this program
    {V[M]();k=0;
     while(vk=v[k]){if(computedby[vk] EQ 0)computedby[vk]=M;else computedby[vk]=-M;k++;}
    }// here "-" means that the object is computated by more than one modi  
}//END.   
    // if a object N is computed by a few modi M0,..,M2
    //   then computedby[N]=-M2, ie the last modus.

int LlistF,*listF=new int[Amount],//modiOperandi to compute ojects, including helping and adjacent(ie for "br" or "sr")
Llistout,listout[Amount],//user choosen objects and their adjacent ones, currently it is computed but not used
LlistU,listU[Amount];//user choosen objects (without their adjacent ones)

double*oaKcorr=new double[Amount];int IsoaKcorr;//correcion dlt!=0 with kappa
void make_oaKcorr(void)
{if (dlt EQ 1) IsoaKcorr=0;
 for (int nf=0;nf<LlistU;nf++)
  { if (attHasKappa[listU[nf]])
        oaKcorr[listU[nf]]=exp(log(dlt)*-attKappa[listU[nf]]);
    else
        oaKcorr[listU[nf]]=1;
  }
}//END
void Kcorr_o(void)
{if (IsoaKcorr) return;
 for (int nf=0;nf<LlistU;nf++)
        o[listU[nf]]=oaKcorr[listU[nf]]*o[listU[nf]];
}//END
void Kcorr_a(void)
{if (IsoaKcorr) return;
 for (int nf=0;nf<LlistU;nf++)
        a[listU[nf]]=oaKcorr[listU[nf]]*a[listU[nf]];
}//END


unsigned char fneeded[Amount];//modi operandi that must be computed, used internally in the next function:
void composingListModiOperandi(int LstageList,int*stageList,int NonBackSack)
{// assigns:  LlistF,*listF,  
 //           oneeded - for memory allocation (ie for objectsMemoryConstructor)
 //           Llistout,listout,LlistU,listU;
int io,j,jf,k,vk,uk;
for (io=0;io<Amount;io++){oneeded[io]=0;fneeded[io]=0;}//Zerofy

for (j=0;j<LstageList;j++){oneeded[stageList[j]]=1;}//User'choice
LlistU=0;for(io=0;io<Amount;io++){if(oneeded[io])listU[LlistU++]=io;}


if (NonBackSack EQ 1)//Back, append objects:
for (j=0;j<LstageList;j++){oneeded[attBack[stageList[j]]]=1;}
if (NonBackSack EQ 2)//Sack, append objects:
for (j=0;j<LstageList;j++){oneeded[attSack[stageList[j]]]=1;}
oneeded[0]=0;oneeded[1]=0;//-redundant, objects 0 and 1 do not exist

Llistout=0;for(io=0;io<Amount;io++){if(oneeded[io])listout[Llistout++]=io;}
//it is just a reodered "stageList" and objects for the adjacent trace (non/back/sack)
//  in case "Non" it coinsides with LlistU,listU
int iwhile=0;
while(1){//forever
if (iwhile++>Amount){PN;PS("???Infinite loop: Error1 in defining modi operandi");exit(1);}
for(io=2;io<Amount;io++)if(oneeded[io]&&(computedby[io]>0))break;//searching positive references "io"
if (io EQ Amount)for(io=1;io<Amount;io++)if(oneeded[io]&&(computedby[io] !=0))break;//if no positive, then negative
if (io EQ Amount)break;//it will happen only if oneeded is empty
int fn=abs(computedby[io]);fneeded[fn]=1;
V[fn]();k=0;while(vk=v[k]){oneeded[vk]=0;k++;}
U[fn]();k=0;while(uk=u[k]){oneeded[uk]=1;k++;}
}//while(1)
// these above lines mean that: 
// (Beg:) first add modi that are non-avoidable 
//  these will compute more objects than the user asked for.    
// but also more object will be needed
// these new objects again should be computed and we start from the (Beg)
// If we got only objects computed by a few(>1) modi each, 
//  then take the first modi.
// A rule is (however, it is not necessary):
//  1. an object N uses objects with numbers less than N 
//  2. if an object N is computed by modi M1 and M2, M1<M2, then 
//     M2 is faster but M1 produces more objects, so N is a by-product of M1.
//      
LlistF=0;for(io=0;io<Amount;io++){if(fneeded[io])listF[LlistF++]=io;}

int S=0;for(io=0;io<Amount;io++)S+=oneeded[io];//S should be zero
if (S>0){PN;PS("???Error2 in defining modi operandi\n it may be that a new operandi is not in UfVArrAssign\n");exit(1);}

for(jf=0;jf<LlistF;jf++)//define objects which may need memory allocation
    if(f[listF[jf]] != NULL){V[listF[jf]]();k=0;while(vk=v[k]){oneeded[vk]=1;k++;}}
    else{PN;PS("???Error3 in defining modi operandi");exit(1);}     
}//END.
void computeObjects_giveNonAdj(void)//tr,lbeg,lend,L,dlt; - should be defined to compute functionals
{ //   uses listF a, fills "o" and "a" 
  //suits for 1)stage=diam, for a full trace matrix, 2)stage=circ 
  // this function is used after composingfistModiOperandi(..,NonBackSack=0)
  //first find start and fin 
int nf,i,j;    
start=L,fin=-1;
for(i=0;i<L;i++)if(tr[i]){start=i;break;}
for(j=L-1;j>=start;j--)if(tr[j]){fin=j;break;}
if (start>fin) //blank or empty track, fill "Out" with default and return:
      {for (nf=0;nf<LlistU;nf++) o[listU[nf]]=attBlank[listU[nf]];
       return;}
//for non-blank track:
span=fin-start+1;lstart=start+lbeg;lfin=fin+lbeg;
//Execute functions listed in listF
for (nf=0;nf<LlistF;nf++) f[listF[nf]](); // "o" is filled. no need for "a"
Kcorr_o();
}//END.


void computeObjects_giveBackAdj(void)//tr,lbeg,lend,L,dlt; - should be defined to compute functionals
{ //suits for 1)stage=trace, 2)stage=diam, trace matrix with symmetry
  // this function is used after composingListModiOperandi(..,NonBackSack=1)
  //first find start and fin
int nf,i,j,lnf;unsigned char ab;    
start=L,fin=-1;
for(i=0;i<L;i++)if(tr[i]){start=i;break;}
for(j=L-1;j>=start;j--)if(tr[j]){fin=j;break;}
if (start>fin) //blank or empty track, fill "Out" with default and return:
      { for (nf=0;nf<LlistU;nf++){lnf=listU[nf];a[lnf]=o[lnf]=attBlank[lnf];}
        return;
      }
//for non-blank track:
span=fin-start+1;lstart=start+lbeg;lfin=fin+lbeg;
//Execute functions listed in listF
for (nf=0;nf<LlistF;nf++) f[listF[nf]](); // o is filled. 
//Filling "a"
double ok;
for (nf=0;nf<LlistU;nf++) 
    {   lnf=listU[nf];a[lnf]=ok=o[lnf];ab=attBack[lnf];//-this is the only difference with the next function "computeObjects_giveSackAdj"
        if (ab EQ 1)  a[lnf]=-ok; 
        if (ab > 1)   a[lnf]=o[ab];      
     }
Kcorr_o();Kcorr_a();
}//END.
void computeObjects_giveSackAdj(void)//tr,lbeg,lend,L,dlt; - should be defined to compute functionals
{ //suits for 1)stage=diam, trace matrix with anti-symmetry
  // this function is used after composingListModiOperandi(..,NonBackSack=2)
  //first find start and fin
int nf,i,j,lnf;unsigned char ab;    
start=L,fin=-1;
for(i=0;i<L;i++)if(tr[i]){start=i;break;}
for(j=L-1;j>=start;j--)if(tr[j]){fin=j;break;}
if (start>fin) //blank or empty track, fill "Out" with default and return:
      { for (nf=0;nf<LlistU;nf++){lnf=listU[nf];a[lnf]=o[lnf]=attBlank[lnf];}
        return;
      }
//for non-blank track:
span=fin-start+1;lstart=start+lbeg;lfin=fin+lbeg;
//Execute functions listed in listF
for (nf=0;nf<LlistF;nf++) f[listF[nf]](); // o is filled. 
//Filling "a"
double ok;
for (nf=0;nf<LlistU;nf++) 
    {   lnf=listU[nf];a[lnf]=ok=o[lnf];ab=attSack[lnf];//-the only difference
        if (ab EQ 1)  a[lnf]=-ok; 
        if (ab > 1)   a[lnf]=o[ab];
    }
Kcorr_o();Kcorr_a();
}//END.