vq.txt

vq算法

/****************************************************************************  
*                                                                           *  
*  VECTOR QUANTIZATION                                                      *  
*                                                                           *  
*****************************************************************************/   
   
#include <STDIO.H>    
#include <STDLIB.H>    
#include <STRING.H>    
#include <CONIO.H>    
#include <MATH.H>    
   
// FUNCTION PROTOTYPES    
   
   
// DEFINES    
#define         SUCCESS         1    
#define         FAILURE         0    
#define         TRUE            1    
#define         FALSE           0    
#define         MAXVECTDIM      20    
#define         MAXPATTERN      20    
#define         MAXCLUSTER      10    
   
// ***** Defined structures & classes *****    
struct aCluster {   
   double       Center[MAXVECTDIM];   
   int          Member[MAXPATTERN];  //Index of Vectors belonging to this cluster    
   int          NumMembers;   
};   
   
struct aVector {   
   double       Center[MAXVECTDIM];   
   int          Size;   
};   
   
class VQsyst {   
private:   
   double       Pattern[MAXPATTERN][MAXVECTDIM+1];   
   aCluster     Cluster[MAXCLUSTER];   
   int          NumPatterns;          // Number of patterns    
   int          SizeVector;           // Number of dimensions in vector    
   int          NumClusters;          // Curr number of clusters    
   double       Threshold;   
   void         Attach(int,int);      // Add spec'd pattern to spec'd    
                                      // Clusters membership list.    
   int          AllocateCluster();    //    
   void         CalcNewClustCenter(int);// find cluster center for modified    
                                         // clusters    
   double       EucNorm(int, int);   // Calc Euclidean norm vector    
   int          FindClosestCluster(int); //ret indx of clust closest to pattern    
                                         //whose index is arg    
   FILE *OutFile;   
public:   
   VQsyst();   
   int InitOutput(char *fname);   
   int LoadPatterns(char *fname);      // Get pattern data to be clustered    
   void RunVQ();                   // Overall control Vector Quant process    
   void ShowClusters();                // Show results on screen    
   void SaveClusters(char *fname);     // Save results to file    
   ~VQsyst(){fclose(OutFile);}   
};   
   
   
//=================IMPLENTATION OF VQ METHODS================================    
   
   
   
//***************************************************************************    
// Constructor    
//***************************************************************************    
   
VQsyst::VQsyst(){   
   NumClusters=0;   
   }   
   
   
//***************************************************************************    
// InitOutput    
//***************************************************************************    
   
int VQsyst::InitOutput(char *fname) {   
if((OutFile = fopen(fname, "w")) == NULL){   
    printf("Unable to open file %s for output",fname);   
    return FAILURE;   
    }   
return SUCCESS;   
}   
   
//***************************************************************************    
// LoadPatterns                                                             *    
//   Loads pattern information from disk.                                   *    
//       1) Number of patterns to be processed                              *    
//       2) Size of the vectors to be processed                             *    
//       3) Max dist permitted between cluster centers                      *    
//       4) Pattern definitions                                             *    
//***************************************************************************    
   
int VQsyst::LoadPatterns(char *fname){   
   FILE *InFilePtr;   
   int    i,j;   
   double x;   
if((InFilePtr = fopen(fname, "r")) == NULL)   
    return FAILURE;   
fscanf(InFilePtr, "%d", &NumPatterns);  // Read # of patterns    
fscanf(InFilePtr, "%d", &SizeVector);   // Read dimension of vector    
fscanf(InFilePtr, "%lg", &Threshold);   // Read Euc dist Threshold.    
printf("The input patterns are:\n");   
fprintf(OutFile,"The input patterns are:\n");   
for (i=0; i<NUMPATTERNS; (dist if this do doesn?t eucnorm because dist="EucNorm(pat,Winner);" %d\n?,Winner); is: cluster closest fprintf(OutFile,?The printf(?The { else } new a allocate so fprintf(OutFile,? printf(? Winner="FindClosestCluster(pat);" -1) (Winner="=" to input curr the Attach %d:\n?,pat); fprintf(OutFile,?\n\nPATTERN printf(?\n\nPATTERN pat++) pat<NumPatterns; (pat="0;" for dist; double pat,Winner; int VQsyst::RunVQ(){ void *************************************************************************** * vectors K first choose We clusters algorithm. VQ of control overall Provides RunVQ SUCCESS; return fprintf(OutFile,?\n?); printf(?\n?); endfor fprintf(OutFile,?Pattern[%d][%d]='%f\n",i,j,Pattern[i][j]);' printf(?Pattern[%d][%d]='%f\n",i,j,Pattern[i][j]);' Pattern[i][j]="x;" elements all consisting fscanf(InFilePtr,?%lg?,&x); pattern create j++) j<SizeVector; (j="0;" vector each For i++)>Threshold) {   
         printf("distance %f > %f", dist,Threshold);   
         printf("\nTherefore cluster %d failed the distance test.\n",Winner);   
         fprintf(OutFile,"distance %f > %f", dist,Threshold);   
         fprintf(OutFile,"\nTherefore cluster %d failed the distance test.\n",Winner);   
         Winner=AllocateCluster();     // Above threshold so allocate new    
         printf("so create NEW cluster number:%d\n",Winner);   
         fprintf(OutFile,"so create NEW cluster number:%d\n",Winner);   
         }   
       else {   
         printf("Distance %f < %f", dist,Threshold);   
         printf("\nTherefore cluster %d passed the distance test.\n",Winner);   
         fprintf(OutFile,"Distance %f < %f", dist,Threshold);   
         fprintf(OutFile,"\nTherefore cluster %d passed the distance test.\n",Winner);   
         } /* endif */                 // cluster    
      } /* endif */   
   printf("patern %d assigned to cluster %d\n",pat,Winner);   
   fprintf(OutFile,"patern %d assigned to cluster %d\n",pat,Winner);   
   Attach(Winner,pat);                 // Attach pattern to winner    
   CalcNewClustCenter(Winner);         // Adapt clust center    
   ShowClusters();    
   } /* endfor */   
}   
   
   
//***************************************************************************    
// AllocateCluster                                                          *    
//    Designate the next free cluster as active                             *    
//***************************************************************************    
   
int VQsyst::AllocateCluster(){   
   int n;   
n=NumClusters;   
NumClusters++;   
return n;   
}   
   
//***************************************************************************    
// EucNorm                                                                  *    
//   Returns the Euclidian norm between a pattern, p, and a cluster         *    
//   center,c-1 he first K vectors to do this                               *    
//***************************************************************************    
   
double VQsyst::EucNorm(int p, int c){   // Calc Euclidean norm of vector difference    
double dist;                            // between pattern vector, p, and cluster    
int i;                                  // center, c.    
dist=0;   
for (i=0; i<SIZEVECTOR if dist cluster closest { } new a to the Attach for dist; double int void *************************************************************************** * vectors clusters of return endfor elements pattern j++) j<SizeVector; (j="0;" vector each i++) %d="=" printf(?\nCLUSTER cl++) cl<NumClusters; (cl="0;" are:?); centers fprintf(OutFile,?\nThe printf(?\nThe cl,i; VQsyst::ShowClusters(){ allocated Display ShowClusters Cluster[c].Center[k]="tmp[k];" tmp[k] traverse k++) k<SizeVector; (k="0;" temp into elmnt (member) add +="(Cluster[c].Center[i]-Pattern[p][i])*(Cluster[c].Center[i]-Pattern[p][i]);" VectID="Cluster[c].Member[j];" member j<Cluster[c].NumMembers; tmp[j]="0.0;" workspace clear tmp[MAXVECTDIM]; VectID,j,k; c){ VQsyst::CalcNewClustCenter(int cluster,c specified center Calculate CalcNewClustCenter Cluster[c].NumMembers++; Cluster[c].Member[MemberIndex]="p;" MemberIndex="Cluster[c].NumMembers;" MemberIndex; p){ c,int VQsyst::Attach(int p. is index whose p) (whose Adds ClustID; endif ?); exist Clusters fprintf(OutFile,?No printf(?No (ClustID<0) ClustID="-1;" MinDist="9.9e+99;" (d<MinDist) d="EucNorm(pat,i);" i<NumClusters; (i="0;" d; MinDist, i, pat){ VQsyst::FindClosestCluster(int distance. Euclidean has pat, pattern, which Returns ClosestCluster Find ;i++){>[%f,%f]", cl,Cluster[cl].Center[0],Cluster[cl].Center[1]);   
   fprintf(OutFile,"\nCLUSTER %d ==>[%f,%f]", cl,Cluster[cl].Center[0],Cluster[cl].Center[1]);   
   } /* endfor */   
printf("\nCLUSTER Membership");   
fprintf(OutFile,"\nCLUSTER Membership");   
for (cl=0; cl<NUMCLUSTERS; { %d="=" cl++) Cluster printf(?\n>{",cl);   
   fprintf(OutFile,"\n  Cluster %d ==>{",cl);   
   for (i=0; i<CLUSTER[CL].NUMMEMBERS; cluster { else } to the for int void *************************************************************************** * clusters of endfor each i++) %d="=" cl++) cl<NumClusters; (cl="0;" centers allocated fprintf(OutFilePtr,?\nCLUSTER output?,fname); %s file open printf(?Unable NULL){ ?r?))="=" if((OutFilePtr="fopen(fname," cl; *OutFilePtr; FILE *fname){ VQsyst::SaveClusters(char designated Store SaveClusters fprintf(OutFile,?}\n?); printf(?}\n?); ?,Cluster[cl].Member[i]); fprintf(OutFile,?%d printf(?%d>[%f,%f]\n",   
              cl,Cluster[cl].Center[0],Cluster[cl].Center[1]);   
      } /* endfor */   
   fclose(OutFilePtr);   
   }   
}   
   
   
//***************************************************************************    
// Main                                                                     *    
//                                                                          *    
//                                                                          *    
//***************************************************************************    
   
main(int argc, char *argv[]) {   
   VQsyst VQ;   
if (argc<3) {   
   printf("USAGE: VQ PATTERN_FILE(input) CLUSTER_FILE(output)\n");   
   exit(0);   
   }   
   
if (VQ.InitOutput(argv[2])==FAILURE)   
   exit (0);   
if (VQ.LoadPatterns(argv[1])==FAILURE ){   
   printf("UNABLE TO READ PATTERN_FILE:%s\n",argv[1]);   
   exit(0);   
   }   
VQ.RunVQ();   
}