clusttool.h File Reference

#include <cstdio>
#include "cluster.h"
#include "host.h"
#include "serialis.h"

Go to the source code of this file.

Functions
uint16_t	ReadSampleSize (tesseract::TFile *fp)
PARAM_DESC *	ReadParamDesc (tesseract::TFile *fp, uint16_t N)
PROTOTYPE *	ReadPrototype (tesseract::TFile *fp, uint16_t N)
float *	ReadNFloats (tesseract::TFile *fp, uint16_t N, float Buffer[])
void	WriteParamDesc (FILE *File, uint16_t N, const PARAM_DESC ParamDesc[])
void	WritePrototype (FILE *File, uint16_t N, PROTOTYPE *Proto)
void	WriteNFloats (FILE *File, uint16_t N, float Array[])
void	WriteProtoStyle (FILE *File, PROTOSTYLE ProtoStyle)
void	WriteProtoList (FILE *File, uint16_t N, PARAM_DESC *ParamDesc, LIST ProtoList, bool WriteSigProtos, bool WriteInsigProtos)

Function Documentation

ReadNFloats()

float* ReadNFloats	(	TFile *	fp,
		uint16_t	N,
		float	Buffer[]
	)

This routine reads N floats from the specified text file and places them into Buffer. If Buffer is nullptr, a buffer is created and passed back to the caller. If EOF is encountered before any floats can be read, nullptr is returned.

Parameters

fp	open text file to read floats from
N	number of floats to read
Buffer	pointer to buffer to place floats into

Returns

Pointer to buffer holding floats or nullptr if EOF

Note

Globals: None

Definition at line 186 of file clusttool.cpp.

                                                          {
  const int kMaxLineSize = 1024;
  char line[kMaxLineSize];
  if (fp->FGets(line, kMaxLineSize) == nullptr) {
    tprintf("Hit EOF in ReadNFloats!\n");
    return nullptr;
  }
  bool needs_free = false;

  if (Buffer == nullptr) {
    Buffer = static_cast<float *>(Emalloc(N * sizeof(float)));
    needs_free = true;
  }

  char *startptr = line;
  for (int i = 0; i < N; i++) {
    char *endptr;
    Buffer[i] = strtof(startptr, &endptr);
    if (endptr == startptr) {
      tprintf("Read of %d floats failed!\n", N);
      if (needs_free) Efree(Buffer);
      return nullptr;
    }
    startptr = endptr;
  }
  return Buffer;
}

ReadParamDesc()

PARAM_DESC* ReadParamDesc	(	TFile *	fp,
		uint16_t	N
	)

This routine reads textual descriptions of sets of parameters which describe the characteristics of feature dimensions.

Parameters

fp	open text file to read N parameter descriptions from
N	number of parameter descriptions to read

Returns

Pointer to an array of parameter descriptors.

Note

Globals: None

Definition at line 61 of file clusttool.cpp.

                                                 {
  PARAM_DESC *ParamDesc;
  char linear_token[TOKENSIZE], essential_token[TOKENSIZE];

  ParamDesc = (PARAM_DESC *) Emalloc (N * sizeof (PARAM_DESC));
  for (int i = 0; i < N; i++) {
    const int kMaxLineSize = TOKENSIZE * 4;
    char line[kMaxLineSize];
    ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
    ASSERT_HOST(sscanf(line,
                "%" QUOTED_TOKENSIZE "s %" QUOTED_TOKENSIZE "s %f %f",
                linear_token, essential_token, &ParamDesc[i].Min,
                &ParamDesc[i].Max) == 4);
    if (linear_token[0] == 'c')
      ParamDesc[i].Circular = TRUE;
    else
      ParamDesc[i].Circular = FALSE;

    if (linear_token[0] == 'e')
      ParamDesc[i].NonEssential = FALSE;
    else
      ParamDesc[i].NonEssential = TRUE;
    ParamDesc[i].Range = ParamDesc[i].Max - ParamDesc[i].Min;
    ParamDesc[i].HalfRange = ParamDesc[i].Range / 2;
    ParamDesc[i].MidRange = (ParamDesc[i].Max + ParamDesc[i].Min) / 2;
  }
  return (ParamDesc);
}

ReadPrototype()

PROTOTYPE* ReadPrototype	(	TFile *	fp,
		uint16_t	N
	)

This routine reads a textual description of a prototype from the specified file.

Parameters

fp	open text file to read prototype from
N	number of dimensions used in prototype

Returns

List of prototypes

Note

Globals: None

Definition at line 99 of file clusttool.cpp.

                                                {
  char sig_token[TOKENSIZE], shape_token[TOKENSIZE];
  PROTOTYPE *Proto;
  int SampleCount;
  int i;

  const int kMaxLineSize = TOKENSIZE * 4;
  char line[kMaxLineSize];
  if (fp->FGets(line, kMaxLineSize) == nullptr ||
      sscanf(line, "%" QUOTED_TOKENSIZE "s %" QUOTED_TOKENSIZE "s %d",
             sig_token, shape_token, &SampleCount) != 3) {
    tprintf("Invalid prototype: %s\n", line);
    return nullptr;
  }
  Proto = (PROTOTYPE *)Emalloc(sizeof(PROTOTYPE));
  Proto->Cluster = nullptr;
  if (sig_token[0] == 's')
    Proto->Significant = TRUE;
  else
    Proto->Significant = FALSE;

  switch (shape_token[0]) {
    case 's':
      Proto->Style = spherical;
      break;
    case 'e':
      Proto->Style = elliptical;
      break;
    case 'a':
      Proto->Style = automatic;
      break;
    default:
      tprintf("Invalid prototype style specification:%s\n", shape_token);
      Proto->Style = elliptical;
  }

  ASSERT_HOST(SampleCount >= 0);
  Proto->NumSamples = SampleCount;

  Proto->Mean = ReadNFloats(fp, N, nullptr);
  ASSERT_HOST(Proto->Mean != nullptr);

  switch (Proto->Style) {
    case spherical:
      ASSERT_HOST(ReadNFloats(fp, 1, &(Proto->Variance.Spherical)) != nullptr);
      Proto->Magnitude.Spherical =
          1.0 / sqrt(2.0 * M_PI * Proto->Variance.Spherical);
      Proto->TotalMagnitude = pow(Proto->Magnitude.Spherical, (float)N);
      Proto->LogMagnitude = log((double)Proto->TotalMagnitude);
      Proto->Weight.Spherical = 1.0 / Proto->Variance.Spherical;
      Proto->Distrib = nullptr;
      break;
    case elliptical:
      Proto->Variance.Elliptical = ReadNFloats(fp, N, nullptr);
      ASSERT_HOST(Proto->Variance.Elliptical != nullptr);
      Proto->Magnitude.Elliptical = (float *)Emalloc(N * sizeof(float));
      Proto->Weight.Elliptical = (float *)Emalloc(N * sizeof(float));
      Proto->TotalMagnitude = 1.0;
      for (i = 0; i < N; i++) {
        Proto->Magnitude.Elliptical[i] =
            1.0 / sqrt(2.0 * M_PI * Proto->Variance.Elliptical[i]);
        Proto->Weight.Elliptical[i] = 1.0 / Proto->Variance.Elliptical[i];
        Proto->TotalMagnitude *= Proto->Magnitude.Elliptical[i];
      }
      Proto->LogMagnitude = log((double)Proto->TotalMagnitude);
      Proto->Distrib = nullptr;
      break;
    default:
      Efree(Proto);
      tprintf("Invalid prototype style\n");
      return nullptr;
  }
  return Proto;
}

ReadSampleSize()

uint16_t ReadSampleSize

(

TFile *

fp

)

This routine reads a single integer from the specified file and checks to ensure that it is between 0 and MAXSAMPLESIZE.

Parameters

fp	open text file to read sample size from

Returns

Sample size

Note

Globals: None

Definition at line 41 of file clusttool.cpp.

                                   {
  int SampleSize = 0;

  const int kMaxLineSize = 100;
  char line[kMaxLineSize];
  ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
  ASSERT_HOST(sscanf(line, "%d", &SampleSize) == 1);
  ASSERT_HOST(SampleSize >= 0 && SampleSize <= MAXSAMPLESIZE);
  return SampleSize;
}

WriteNFloats()

void WriteNFloats	(	FILE *	File,
		uint16_t	N,
		float	Array[]
	)

This routine writes a text representation of N floats from an array to a file. All of the floats are placed on one line.

Parameters

File	open text file to write N floats to
N	number of floats to write
Array	array of floats to write

Returns

None

Note

Globals: None

Definition at line 298 of file clusttool.cpp.

                                                          {
  for (int i = 0; i < N; i++)
    fprintf(File, " %9.6f", Array[i]);
  fprintf(File, "\n");
}

WriteParamDesc()

void WriteParamDesc	(	FILE *	File,
		uint16_t	N,
		const PARAM_DESC	ParamDesc[]
	)

This routine writes an array of dimension descriptors to the specified text file.

Parameters

File	open text file to write param descriptors to
N	number of param descriptors to write
ParamDesc	array of param descriptors to write

Returns

None

Note

Globals: None

Definition at line 223 of file clusttool.cpp.

                                                                          {
  int i;

  for (i = 0; i < N; i++) {
    if (ParamDesc[i].Circular)
      fprintf (File, "circular ");
    else
      fprintf (File, "linear   ");

    if (ParamDesc[i].NonEssential)
      fprintf (File, "non-essential ");
    else
      fprintf (File, "essential     ");

    fprintf (File, "%10.6f %10.6f\n", ParamDesc[i].Min, ParamDesc[i].Max);
  }
}

WriteProtoList()

void WriteProtoList	(	FILE *	File,
		uint16_t	N,
		PARAM_DESC *	ParamDesc,
		LIST	ProtoList,
		bool	WriteSigProtos,
		bool	WriteInsigProtos
	)

This routine writes a textual description of each prototype in the prototype list to the specified file. It also writes a file header which includes the number of dimensions in feature space and the descriptions for each dimension.

Parameters

File	open text file to write prototypes to
N	number of dimensions in feature space
ParamDesc	descriptions for each dimension
ProtoList	list of prototypes to be written
WriteSigProtos	TRUE to write out significant prototypes
WriteInsigProtos	TRUE to write out insignificants

Note

Globals: None

Returns

None

Definition at line 345 of file clusttool.cpp.

                                           {
  PROTOTYPE *Proto;

  /* write file header */
  fprintf(File,"%0d\n",N);
  WriteParamDesc(File,N,ParamDesc);

  /* write prototypes */
  iterate(ProtoList)
    {
      Proto = (PROTOTYPE *) first_node (ProtoList);
      if ((Proto->Significant && WriteSigProtos) ||
          (!Proto->Significant && WriteInsigProtos))
        WritePrototype(File, N, Proto);
    }
}

WriteProtoStyle()

void WriteProtoStyle	(	FILE *	File,
		PROTOSTYLE	ProtoStyle
	)

This routine writes to the specified text file a word which represents the ProtoStyle. It does not append a carriage return to the end.

Parameters

File	open text file to write prototype style to
ProtoStyle	prototype style to write

Returns

None

Note

Globals: None

Definition at line 313 of file clusttool.cpp.

                                                        {
  switch (ProtoStyle) {
    case spherical:
      fprintf (File, "spherical");
      break;
    case elliptical:
      fprintf (File, "elliptical");
      break;
    case mixed:
      fprintf (File, "mixed");
      break;
    case automatic:
      fprintf (File, "automatic");
      break;
  }
}

WritePrototype()

void WritePrototype	(	FILE *	File,
		uint16_t	N,
		PROTOTYPE *	Proto
	)

This routine writes a textual description of a prototype to the specified text file.

Parameters

File	open text file to write prototype to
N	number of dimensions in feature space
Proto	prototype to write out

Returns

None

Note

Globals: None

Definition at line 250 of file clusttool.cpp.

                                                              {
  int i;

  if (Proto->Significant)
    fprintf (File, "significant   ");
  else
    fprintf (File, "insignificant ");
  WriteProtoStyle (File, (PROTOSTYLE) Proto->Style);
  fprintf (File, "%6d\n\t", Proto->NumSamples);
  WriteNFloats (File, N, Proto->Mean);
  fprintf (File, "\t");

  switch (Proto->Style) {
    case spherical:
      WriteNFloats (File, 1, &(Proto->Variance.Spherical));
      break;
    case elliptical:
      WriteNFloats (File, N, Proto->Variance.Elliptical);
      break;
    case mixed:
      for (i = 0; i < N; i++)
      switch (Proto->Distrib[i]) {
        case normal:
          fprintf (File, " %9s", "normal");
          break;
        case uniform:
          fprintf (File, " %9s", "uniform");
          break;
        case D_random:
          fprintf (File, " %9s", "random");
          break;
        case DISTRIBUTION_COUNT:
          ASSERT_HOST(!"Distribution count not allowed!");
      }
      fprintf (File, "\n\t");
      WriteNFloats (File, N, Proto->Variance.Elliptical);
  }
}