KKLSC::ScannerFile Class Reference

#include <base>

Inheritance diagram for KKLSC::ScannerFile:

Public Types
enum	Format {   Format::sfSimple, Format::sf2BitEncoded, Format::sf3BitEncoded, Format::sf4BitEncoded,   Format::sfZlib3BitEncoded, Format::sfUnKnown }
enum	IOMode { ioRead, ioWrite }
typedef ScannerFile *	ScannerFilePtr

Public Member Functions
	ScannerFile (const KKStr &_fileName, RunLog &_log)
	ScannerFile (const KKStr &_fileName, kkuint32 _pixelsPerScanLine, kkuint32 _frameHeight, RunLog &_log)
virtual	~ScannerFile ()
void	AddHeaderField (const KKStr &_fieldName, const KKStr &_fieldValue)
void	AddHeaderFields (const ScannerHeaderFieldsPtr _headerFields)
void	AddStartPoint (kkint32 _scanLineNum)
	Adds a Start-Point to the 'StartStopPoints' list. More...
void	AddStopPoint (kkint32 _scanLineNum)
	Adds a Stop-Point to the 'StartStopPoints' list. More...
void	BuildFrameOffsets (const volatile bool &cancelFlag)
	Will update the 'frameOffsets' table by scanning the file from the last known entry until the end of file. More...
bool	BuildFrameOffsetsRunning () const
kkint64	ByteOffsetScanLineZero () const
virtual void	Close ()
bool	Eof () const
virtual Format	FileFormat () const
KKStr	FileFormatStr () const
const KKStr &	FileName () const
kkint64	FileSizeInBytes () const
bool	FlatFieldEnabled () const
kkuint32	FlowMeterCounter () const
kkuint32	FlowMeterCounterScanLine () const
virtual void	Flush ()
uchar *	FrameBuffer () const
kkint64	FrameBufferFileOffsetLast () const
kkint64	FrameBufferFileOffsetNext () const
kkint32	FrameHeight () const
bool	FrameOffsetsLoaded () const
void	FrameRead (kkuint32 frameNum, bool &found)
	Read into frame buffer 'frameNum' and reposition so that next scan-line will be the 1st line in the frame. More...
virtual void	GetNextLine (uchar *lineBuff, kkuint32 lineBuffSize, kkuint32 &lineSize, kkuint32 colCount[], kkuint32 &pixelsInRow)
const KKStr &	GetValue (const KKStr &fieldName)
float	GetValueFloat (const KKStr &fieldName)
ScannerHeaderFieldsPtr	HeaderFields () const
void	InitiateWritting ()
kkint32	LargestKnowmFrameNum () const
kkint32	LargestKnownScanLine () const
kkint32	LastScanLine () const
void	LoadIndexFile (bool &successful)
	Call this method to Load the FrameOffsets and StartStop points from the index file. More...
virtual kkint32	MemoryConsumedEstimated () const
kkint32	NextScanLine () const
bool	Opened () const
kkuint32	PixelsPerScanLine () const
VectorFloatPtr	RecordRateByTimeIntervals (int intervalSecs)
	Returns an array indication the record rate in bytes/sec for specified time-intervals. More...
void	Reset ()
float	ScanRate () const
virtual void	ScanRate (float _scanRate)
void	SkipNextLine ()
void	SkipToScanLine (kkint32 scanLine)
	Repositions the file such that the next call to 'GetNextLine' returns the 'scanLine' scan-line. More...
void	StartStopPointDelete (kkint32 _scanLineNum)
StartStopPointPtr	StartStopPointNearestEntry (kkint32 _scanLineNum)
StartStopPointPtr	StartStopPointPrevEntry (kkint32 _scanLineNum)
const StartStopPointList &	StartStopPoints () const
StartStopPointPtr	StartStopPointSuccEntry (kkint32 _scanLineNum)
virtual void	WriteInstrumentDataWord (uchar idNum, kkuint32 scanLineNum, WordFormat32Bits dataWord)
	Writes a 32 bit number into the Scanner File Stream at current location. More...
virtual void	WriteScanLine (const uchar *buffer, kkuint32 bufferLen)
virtual void	WriteTextBlock (const uchar *txtBlock, kkuint32 txtBlockLen)=0

Static Public Member Functions
static const uchar *	ConpensationTable (Format format)
static ScannerFilePtr	CreateScannerFile (KKStr _fileName, RunLog &_log)
static ScannerFilePtr	CreateScannerFileForOutput (const KKStr &_fileName, Format _format, kkuint32 _pixelsPerScanLine, kkuint32 _frameHeight, RunLog &_log)
static ScannerFilePtr	CreateScannerFileForOutput (const KKStr &_fileName, const KKStr &_formatStr, kkuint32 _pixelsPerScanLine, kkuint32 _frameHeight, RunLog &_log)
static void	GetScannerFileParameters (const KKStr &_scannerFileName, ScannerHeaderFieldsPtr &_headerFields, Format &_scannerFileFormat, kkint32 &_frameHeight, kkint32 &_frameWidth, float &_scanRate, bool &_successful, RunLog &_log)
	Retrieves statistics for a specified Scanner File. More...
static Format	GuessFormatOfFile (const KKStr &_fileName, RunLog &_log)
static Format	ScannerFileFormatFromStr (const KKStr &fileFormatStr)
static const KKStr &	ScannerFileFormatToStr (Format fileFormat)

Protected Member Functions
void	AddStartStopEntryToIndexFile (kkint32 scanLineNum, StartStopPoint::StartStopType type, bool deleteEntry)
void	AllocateFrameBuffer ()
void	CreateGoalie ()
void	DetermineFrameOffsetForFrame (kkuint32 frameNum)
	Updates the byte offset for specified entry in 'frameOffsets' that is currently flagged with "-1". More...
void	ExtractHeaderField (const KKStr &fieldName, const KKStr &fieldValue)
kkint32	FSeek (kkint64 filePos)
kkint64	GetFrameOffset (kkuint32 frameNum)
void	Open (const KKStr &_fileName)
virtual kkuint32	ReadBufferFrame ()=0
	Read in one Scanner File Frame return number of actual scan-lines read. More...
void	ReadHeader ()
void	ReportInstrumentDataWord (uchar idNum, kkuint32 scanLineNum, WordFormat32Bits dataWord)
void	ReportTextMsg (const char *textBuff, kkint32 numTextBytes)
	Text messages that are embedded in a scanner file can be reported here. More...
void	SaveIndexFile (std::vector< kkint64 > &frameOffsets)
void	SkipBytesForward (kkuint32 numBytes)
virtual kkint64	SkipToNextFrame ()=0
	Skip to start of next frame returning back byte offset of that frame. More...
void	UpdateFrameOffset (kkuint32 frameNum, kkuint32 scanLineNum, kkint64 byteOffset)
virtual void	WriteBufferFrame ()=0
	Write the contents of 'frameBuffer' to he end of the scanner file. More...
void	WriteHeader ()
	This method is called before any scanner data is added to the file. It will write the header information for the file. More...

Static Protected Member Functions
static void	ReadHeaderOneLine (FILE *f, bool &endOfText, KKStr &line)

Protected Attributes
kkint64	byteOffsetScanLineZero
bool	eof
FILE *	file
KKStr	fileName
kkint64	fileSizeInBytes
bool	flatFieldEnabled
kkuint32	flowMeterCounter
kkuint32	flowMeterCounterScanLine
uchar *	frameBuffer
kkint64	frameBufferFileOffsetLast
kkint64	frameBufferFileOffsetNext
bool	frameBufferLastReadEof
kkuint32	frameBufferLen
kkuint32	frameBufferNextLine
kkuint32	frameBufferNumScanLines
kkuint32	frameBufferSize
kkuint32	frameHeight
kkuint32	frameNumCurLoaded
std::vector< kkint64 >	frameOffsets
bool	frameOffsetsBuildRunning
bool	frameOffsetsLoaded
GoalKeeperPtr	goalie
bool	headerDataWritten
ScannerHeaderFieldsPtr	headerFields
std::ofstream *	indexFile
KKStr	indexFileName
IOMode	ioMode
kkint32	largestKnownScanLine
kkint32	lastScanLine
RunLog &	log
kkint32	nextScanLine
bool	opened
kkuint32	pixelsPerScanLine
ScannerFileEntryPtr	scannerFileEntry
float	scanRate
StartStopPointList	startStopPoints

Static Protected Attributes
static const KKStr	fileFormatOptions []

Detailed Description

class to be used for all the different Scanner File Formats.

Definition at line 45 of file ScannerFile.h.

Member Typedef Documentation

typedef ScannerFile* KKLSC::ScannerFile::ScannerFilePtr

Definition at line 48 of file ScannerFile.h.

Member Enumeration Documentation

enum KKLSC::ScannerFile::Format

strong

Enumerator
sfSimple
sf2BitEncoded
sf3BitEncoded
sf4BitEncoded
sfZlib3BitEncoded
sfUnKnown

Definition at line 50 of file ScannerFile.h.

                   {sfSimple,
                    sf2BitEncoded,
                    sf3BitEncoded,
                    sf4BitEncoded,
                    sfZlib3BitEncoded,
                    sfUnKnown
                   };

enum KKLSC::ScannerFile::IOMode

Enumerator
ioRead
ioWrite

Definition at line 59 of file ScannerFile.h.

{ioRead,  ioWrite}  IOMode;

Constructor & Destructor Documentation

ScannerFile::ScannerFile	(	const KKStr &	_fileName,
		RunLog &	_log
	)

Constructor for opening file for reading

Definition at line 40 of file ScannerFile.cpp.

References AllocateFrameBuffer(), byteOffsetScanLineZero, CreateGoalie(), eof, file, fileName, fileSizeInBytes, flatFieldEnabled, flowMeterCounter, flowMeterCounterScanLine, frameBuffer, frameBufferFileOffsetLast, frameBufferFileOffsetNext, frameBufferLastReadEof, frameBufferLen, frameBufferNextLine, frameBufferNumScanLines, frameBufferSize, frameHeight, frameNumCurLoaded, frameOffsetsBuildRunning, frameOffsetsLoaded, KKLSC::ScannerFileEntry::FullName(), KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry(), goalie, headerDataWritten, headerFields, indexFile, indexFileName, ioMode, ioRead, KKB::KKStr::KKStr(), largestKnownScanLine, lastScanLine, log, nextScanLine, Open(), opened, KKB::osFTELL(), KKB::osGetRootName(), KKLSC::ScannerFileEntry::PixelsPerScanLine(), pixelsPerScanLine, ReadHeader(), ScannerFile(), scannerFileEntry, KKLSC::ScannerFileEntry::ScanRate(), scanRate, and UpdateFrameOffset().

Referenced by ScannerFile(), KKLSC::ScannerFile2BitEncoded::ScannerFile2BitEncoded(), KKLSC::ScannerFile3BitEncoded::ScannerFile3BitEncoded(), KKLSC::ScannerFile4BitEncoded::ScannerFile4BitEncoded(), and KKLSC::ScannerFileZLib3BitEncoded::ScannerFileZLib3BitEncoded().

                           :
  byteOffsetScanLineZero    (0),
  eof                       (false),
  file                      (NULL),
  fileName                  (_fileName),
  fileSizeInBytes           (0),
  flatFieldEnabled          (false),
  frameHeight               (0),
  headerDataWritten         (false),
  headerFields              (NULL),
  ioMode                    (ioRead),
  largestKnownScanLine      (-1),
  lastScanLine              (0),
  log                       (_log),
  nextScanLine              (0),
  opened                    (false),
  pixelsPerScanLine         (4096),
  scanRate                  (20000),

  flowMeterCounter          (0),
  flowMeterCounterScanLine  (0),
  frameBuffer               (NULL),
  frameBufferFileOffsetLast (0),
  frameBufferFileOffsetNext (0),
  frameBufferLastReadEof    (false),
  frameBufferLen            (0),
  frameBufferNextLine       (0),
  frameBufferNumScanLines   (0),
  frameBufferSize           (0),
  frameNumCurLoaded         (0),
  frameOffsets              (),
  frameOffsetsBuildRunning  (false),
  frameOffsetsLoaded        (false),
  goalie                    (NULL),
  indexFile                 (NULL),
  indexFileName             (),
  scannerFileEntry          (NULL),
  startStopPoints           ()
{
  CreateGoalie ();

  scannerFileEntry = ScannerFileEntry::GetOrCreateScannerFileEntry (osGetRootName (fileName));
  scannerFileEntry->FullName (fileName);

  Open (fileName); 
  if  (opened)
  {
    ReadHeader ();
    byteOffsetScanLineZero = osFTELL (file);
    if  (frameHeight == 0)
      frameHeight = pixelsPerScanLine;
    AllocateFrameBuffer ();
    UpdateFrameOffset (0, 0, byteOffsetScanLineZero);
    scannerFileEntry->PixelsPerScanLine (pixelsPerScanLine);
    scannerFileEntry->ScanRate (scanRate);
  }
}

ScannerFile::ScannerFile	(	const KKStr &	_fileName,
		kkuint32	_pixelsPerScanLine,
		kkuint32	_frameHeight,
		RunLog &	_log
	)

Constructor for opening file for Writing

Definition at line 104 of file ScannerFile.cpp.

References AllocateFrameBuffer(), byteOffsetScanLineZero, eof, file, fileName, fileSizeInBytes, flatFieldEnabled, flowMeterCounter, flowMeterCounterScanLine, frameBuffer, frameBufferFileOffsetLast, frameBufferFileOffsetNext, frameBufferLastReadEof, frameBufferLen, frameBufferNextLine, frameBufferNumScanLines, frameBufferSize, frameHeight, frameNumCurLoaded, frameOffsetsBuildRunning, frameOffsetsLoaded, KKLSC::ScannerFileEntry::FullName(), KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry(), goalie, headerDataWritten, headerFields, indexFile, indexFileName, ioMode, ioWrite, KKB::KKStr::KKStr(), largestKnownScanLine, lastScanLine, log, nextScanLine, Open(), opened, KKB::osFTELL(), KKB::osGetRootName(), KKLSC::ScannerFileEntry::PixelsPerScanLine(), pixelsPerScanLine, ScannerFile(), scannerFileEntry, and scanRate.

Referenced by ScannerFile(), KKLSC::ScannerFile2BitEncoded::ScannerFile2BitEncoded(), KKLSC::ScannerFile3BitEncoded::ScannerFile3BitEncoded(), KKLSC::ScannerFile4BitEncoded::ScannerFile4BitEncoded(), and KKLSC::ScannerFileZLib3BitEncoded::ScannerFileZLib3BitEncoded().

                           :

  byteOffsetScanLineZero    (0),
  eof                       (false),
  file                      (NULL),
  fileName                  (_fileName),
  fileSizeInBytes           (0),
  flatFieldEnabled          (false),
  frameHeight               (_frameHeight),
  headerDataWritten         (false),
  headerFields              (NULL),
  ioMode                    (ioWrite),
  largestKnownScanLine      (-1),
  lastScanLine              (0),
  log                       (_log),
  nextScanLine              (0),
  opened                    (false),
  pixelsPerScanLine         (_pixelsPerScanLine),
  scanRate                  (20000),

  flowMeterCounter          (0),
  flowMeterCounterScanLine  (0),
  frameBuffer               (NULL),
  frameBufferFileOffsetLast (0),
  frameBufferFileOffsetNext (0),
  frameBufferLastReadEof    (false),
  frameBufferLen            (0),
  frameBufferNextLine       (0),
  frameBufferNumScanLines   (0),
  frameBufferSize           (0),
  frameNumCurLoaded         (0),
  frameOffsets              (),
  frameOffsetsBuildRunning  (false),
  frameOffsetsLoaded        (false),
  goalie                    (NULL),
  indexFile                 (NULL),
  indexFileName             (),
  scannerFileEntry          (NULL),
  startStopPoints           ()
{
  scannerFileEntry = ScannerFileEntry::GetOrCreateScannerFileEntry (osGetRootName (fileName));
  scannerFileEntry->FullName (fileName);
  scannerFileEntry->PixelsPerScanLine (pixelsPerScanLine);

  Open (fileName);
  if  (opened)
  {
    byteOffsetScanLineZero = osFTELL (file);
    AllocateFrameBuffer ();
    //UpdateFrameOffset (0, 0, byteOffsetScanLineZero);
  }
}

ScannerFile::~ScannerFile ( )

virtual

Definition at line 163 of file ScannerFile.cpp.

References Close(), KKB::GoalKeeper::Destroy(), frameBuffer, goalie, headerFields, and opened.

{
  if  (opened)
    Close ();

  delete  headerFields;  headerFields = NULL;
  delete  frameBuffer;   frameBuffer  = NULL;
  
  GoalKeeper::Destroy (goalie);
  goalie = NULL;
}

Member Function Documentation

void ScannerFile::AddHeaderField	(	const KKStr &	_fieldName,
		const KKStr &	_fieldValue
	)

Definition at line 1082 of file ScannerFile.cpp.

References KKLSC::ScannerHeaderFields::Add(), ExtractHeaderField(), headerFields, and KKLSC::ScannerHeaderFields::ScannerHeaderFields().

Referenced by InitiateWritting().

{
  if  (!headerFields)
    headerFields = new ScannerHeaderFields ();
  headerFields->Add (_fieldName, _fieldValue);
  ExtractHeaderField (_fieldName, _fieldValue);
} /* AddHeaderField */

void ScannerFile::AddHeaderFields

(

const ScannerHeaderFieldsPtr

_headerFields

)

Definition at line 1094 of file ScannerFile.cpp.

References KKLSC::ScannerHeaderFields::EndBlock(), and KKLSC::ScannerHeaderFields::StartBlock().

{
  _headerFields->StartBlock ();

  ScannerHeaderFields::const_iterator  idx;
  for  (idx = _headerFields->begin ();  idx != _headerFields->end ();  ++idx)
    AddHeaderField (idx->first, idx->second);

  _headerFields->EndBlock ();
}  /* AddHeaderFields */

void ScannerFile::AddStartPoint

(

kkint32

_scanLineNum

)

Adds a Start-Point to the 'StartStopPoints' list.

Definition at line 355 of file ScannerFile.cpp.

References AddStartStopEntryToIndexFile(), and KKLSC::StartStopPoint::StartPoint.

{
  startStopPoints.AddEntry (_scanLineNum, StartStopPoint::StartStopType::StartPoint);
  AddStartStopEntryToIndexFile (_scanLineNum, StartStopPoint::StartStopType::StartPoint, false);
}

void ScannerFile::AddStartStopEntryToIndexFile ( kkint32  scanLineNum, StartStopPoint::StartStopType  type, bool  deleteEntry  )

protected

Definition at line 314 of file ScannerFile.cpp.

References CreateGoalie(), KKB::KKStr::Empty(), KKB::GoalKeeper::EndBlock(), goalie, indexFile, indexFileName, KKB::osSleepMiliSecs(), and KKB::GoalKeeper::StartBlock().

Referenced by AddStartPoint(), AddStopPoint(), and StartStopPointDelete().

{
  if  (indexFileName.Empty ())
    return;

  CreateGoalie ();

  bool  clearToUpdate = false;
  while  (!clearToUpdate)
  {
    goalie->StartBlock ();
    if  (indexFile != NULL)
    {
      goalie->EndBlock ();
      osSleepMiliSecs (10);
    }
    else
    {
      clearToUpdate = true;
    }
  }

  indexFile = new ofstream (indexFileName.Str (), ios_base::app);

  if  (deleteEntry)
    *indexFile << "DeleteStartStopPoint" << "\t" << scanLineNum << endl;
  else
    *indexFile << "StartStopPoint" << "\t" << scanLineNum << "\t" << StartStopPoint::StartStopTypeToStr (type) << endl;

  indexFile->close ();
  delete  indexFile;
  indexFile = NULL;
  goalie->EndBlock ();
}

void ScannerFile::AddStopPoint

(

kkint32

_scanLineNum

)

Adds a Stop-Point to the 'StartStopPoints' list.

Definition at line 363 of file ScannerFile.cpp.

References AddStartStopEntryToIndexFile(), and KKLSC::StartStopPoint::StopPoint.

{
  startStopPoints.AddEntry (_scanLineNum, StartStopPoint::StartStopType::StopPoint);
  AddStartStopEntryToIndexFile (_scanLineNum, StartStopPoint::StartStopType::StopPoint, false);
}

void ScannerFile::AllocateFrameBuffer ( )

protected

Definition at line 195 of file ScannerFile.cpp.

References frameBuffer, frameBufferLen, frameBufferSize, frameHeight, and pixelsPerScanLine.

Referenced by ScannerFile().

{
  delete  frameBuffer;   frameBuffer = NULL;
  frameBufferSize = frameHeight * pixelsPerScanLine;
  frameBufferLen  = 0;
  frameBuffer = new uchar[frameBufferSize];
}

void ScannerFile::BuildFrameOffsets

(

const volatile bool &

cancelFlag

)

Will update the 'frameOffsets' table by scanning the file from the last known entry until the end of file.

It would be best to call this method using a separate thread. The method will utilize synchronization code to prevent interference with the other access methods such as 'GetNextLine', 'FrameRead', etc. The idea is that it will not interfere with file positioning.

Parameters

[in]

cancelFlag

This Boolean variable will be monitored by the method; if it turns true it will terminate and return immediately.

Definition at line 1195 of file ScannerFile.cpp.

References CreateGoalie(), KKB::GoalKeeper::EndBlock(), file, frameHeight, frameOffsetsBuildRunning, frameOffsetsLoaded, FSeek(), goalie, largestKnownScanLine, LoadIndexFile(), KKB::GoalKeeper::NumBlockedThreads(), KKB::osFTELL(), KKB::osSleepMiliSecs(), SkipToNextFrame(), and KKB::GoalKeeper::StartBlock().

{
  CreateGoalie ();
  goalie->StartBlock ();

  kkint64  origFilePos = osFTELL (file);

  frameOffsetsBuildRunning = true;

  bool  changesMadeToIndexFile = false;
  bool  loadSuccessful = false;
  LoadIndexFile (loadSuccessful);
  if  (!loadSuccessful)
    changesMadeToIndexFile = true;

  {
    if  (frameOffsets.size () < 1)
      frameOffsets.push_back (byteOffsetScanLineZero);

    // Update any entries that are pointing to -1.
    for  (kkuint32 frameNum = 0;  frameNum < frameOffsets.size ();  ++frameNum)
    {
      if  (frameOffsets[frameNum] < 0)
      {
        if  (goalie->NumBlockedThreads () > 0)
        {
          // Since other threads are currently blocked trying to get access to this resource;  we will release
          // it for 10 mili-secs before we continue.
          FSeek (origFilePos);
          goalie->EndBlock ();
          osSleepMiliSecs (10);
          goalie->StartBlock ();
          origFilePos = osFTELL (file);
        }
         changesMadeToIndexFile = true;
        DetermineFrameOffsetForFrame (frameNum);
      }
    }

    bool  readToEOF = false;
    while  ((!readToEOF)  &&  (!cancelFlag))
    {
      kkuint32  loopCount = 0;

      if  (goalie->NumBlockedThreads () > 0)
      {
        // Give other threads a chance to access this instance of ScannerFile.
        FSeek (origFilePos);
        goalie->EndBlock ();
        while  ((goalie->NumBlockedThreads () > 0)  &&  (loopCount < 10))
        {
          osSleepMiliSecs (10);
          ++loopCount;
        }
        goalie->StartBlock ();
        origFilePos = osFTELL (file);
      }

      kkuint32  lastFrameNum = frameOffsets.size () - 1;

      // Reposition to beginning of last frame that is recorded in frameOfsets.
      FSeek (frameOffsets[lastFrameNum]);
      
      kkint64  nextFrameByteOffset = SkipToNextFrame ();
      while  ((nextFrameByteOffset >= 0)  &&  (goalie->NumBlockedThreads () < 1))
      {
        kkint32 fileSizeInScanLines = (lastFrameNum + 1) * frameHeight;
        if  (fileSizeInScanLines > largestKnownScanLine)
          largestKnownScanLine = fileSizeInScanLines;
        frameOffsets.push_back (nextFrameByteOffset);
        ++lastFrameNum;
        changesMadeToIndexFile = true;
        nextFrameByteOffset = SkipToNextFrame ();
      }

      if  (nextFrameByteOffset < 0)
       readToEOF = true;
    }

    if  ((!cancelFlag)  &&  changesMadeToIndexFile)
      SaveIndexFile (frameOffsets);
  }

  if  (!cancelFlag)
    frameOffsetsLoaded = true;

  FSeek (origFilePos);

  goalie->EndBlock ();

  frameOffsetsBuildRunning = false;

  return;
}  /* BuildFrameOffsets */

bool KKLSC::ScannerFile::BuildFrameOffsetsRunning ( ) const

inline

Definition at line 89 of file ScannerFile.h.

References frameOffsetsBuildRunning.

{return  frameOffsetsBuildRunning;}

kkint64 KKLSC::ScannerFile::ByteOffsetScanLineZero ( ) const

inline

Byte offset of 1st scan line after header field.

Definition at line 90 of file ScannerFile.h.

References byteOffsetScanLineZero.

void ScannerFile::Close ( )

virtual

Definition at line 205 of file ScannerFile.cpp.

References file, frameBufferNextLine, indexFile, ioMode, ioWrite, opened, and WriteBufferFrame().

Referenced by ~ScannerFile().

{
  if  (opened  &&  (ioMode == ScannerFile::ioWrite))
  {
    if  (frameBufferNextLine > 0)
      WriteBufferFrame ();
    fclose (file);
    file = NULL;

    if  (indexFile)
    {
      indexFile->close ();
      delete  indexFile;
      indexFile = NULL;
    }

    opened = false;
  }
}

const uchar * ScannerFile::ConpensationTable ( Format  format )

static

Definition at line 816 of file ScannerFile.cpp.

References KKLSC::ScannerFileSimple::CompensationTable(), KKLSC::ScannerFile2BitEncoded::CompensationTable(), KKLSC::ScannerFile3BitEncoded::CompensationTable(), KKLSC::ScannerFile4BitEncoded::CompensationTable(), sf2BitEncoded, sf3BitEncoded, sf4BitEncoded, sfSimple, sfUnKnown, and sfZlib3BitEncoded.

{
  const uchar*  result = NULL;

  switch  (format)
  {
  case  Format::sfSimple:      
    result = ScannerFileSimple::CompensationTable ();
    break;

  case  Format::sf2BitEncoded:
    result = ScannerFile2BitEncoded::CompensationTable ();
    break;

  case  Format::sf3BitEncoded:
    result = ScannerFile3BitEncoded::CompensationTable ();
    break;

  case  Format::sf4BitEncoded:
    result = ScannerFile4BitEncoded::CompensationTable ();
    break;

  case  Format::sfUnKnown:
  case  Format::sfZlib3BitEncoded:
    result = NULL;
    break;
  }
  return  result;
}  /* ConpensationTable */

void ScannerFile::CreateGoalie ( )

protected

Definition at line 304 of file ScannerFile.cpp.

References KKB::GoalKeeper::Create(), fileName, goalie, KKB::operator+(), and KKB::osGetRootName().

Referenced by AddStartStopEntryToIndexFile(), BuildFrameOffsets(), DetermineFrameOffsetForFrame(), ScannerFile(), and UpdateFrameOffset().

{
  if  (!goalie)
  {
    GoalKeeper::Create ("ScannerFile-" + osGetRootName (fileName), goalie);
  }
}

ScannerFilePtr ScannerFile::CreateScannerFile ( KKStr  _fileName, RunLog &  _log  )

static

Definition at line 787 of file ScannerFile.cpp.

References GuessFormatOfFile(), and sfUnKnown.

Referenced by GetScannerFileParameters().

{
  Format  format = GuessFormatOfFile (_fileName, _log);
  if  (format == Format::sfUnKnown)
    return NULL;

  if  (format == Format::sfSimple)
    return new ScannerFileSimple (_fileName, _log);

  if  (format == Format::sf2BitEncoded)
    return new ScannerFile2BitEncoded (_fileName, _log);

  if  (format == Format::sf3BitEncoded)
    return new ScannerFile3BitEncoded (_fileName, _log);

  if  (format == Format::sf4BitEncoded)
    return new ScannerFile4BitEncoded (_fileName, _log);

  if  (format == Format::sfZlib3BitEncoded)
    return new ScannerFileZLib3BitEncoded (_fileName, _log);

  return NULL;
}  /* CreateScanLineFile */

ScannerFilePtr ScannerFile::CreateScannerFileForOutput ( const KKStr &  _fileName, Format  _format, kkuint32  _pixelsPerScanLine, kkuint32  _frameHeight, RunLog &  _log  )

static

Definition at line 848 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), KKB::osFileExists(), and sfUnKnown.

Referenced by CreateScannerFileForOutput().

{
  ScannerFilePtr  scannerFile = NULL;
  if  (osFileExists (_fileName))
  {
    KKStr  errMsg;
    errMsg << "ScannerFile::CreateScannerFileForOutput   ***ERROR***   ScannerFile[" << _fileName << "]  already exists.";
    _log.Level (-1) << endl << endl << errMsg << endl << endl;
  }
  else
  {
    switch  (_format)
    {
    case  Format::sfSimple:      
      scannerFile = new ScannerFileSimple (_fileName, _pixelsPerScanLine, _frameHeight, _log);
      break;

    case  Format::sf2BitEncoded:
      scannerFile = new ScannerFile2BitEncoded (_fileName, _pixelsPerScanLine, _frameHeight, _log);
      break;

    case  Format::sf3BitEncoded:
      scannerFile = new ScannerFile3BitEncoded (_fileName, _pixelsPerScanLine, _frameHeight, _log);
      break;

    case  Format::sf4BitEncoded:
      scannerFile = new ScannerFile4BitEncoded (_fileName, _pixelsPerScanLine, _frameHeight, _log);
      break;

    case  Format::sfZlib3BitEncoded:
      scannerFile = new ScannerFileZLib3BitEncoded (_fileName, _pixelsPerScanLine, _frameHeight, _log);
      break;

    case  Format::sfUnKnown:
      scannerFile = NULL;
      break;

    }

    if  (!scannerFile)
    {
      KKStr  errMsg;
      errMsg << "ScannerFile::CreateScannerFileForOutput   ***ERROR***   Invalid ScannerFile Format specified.";
      _log.Level (-1) << endl << endl << errMsg << endl << endl;
    }
  }

  return  scannerFile;
}  /* CreateScannerFileForOutput */

ScannerFilePtr ScannerFile::CreateScannerFileForOutput ( const KKStr &  _fileName, const KKStr &  _formatStr, kkuint32  _pixelsPerScanLine, kkuint32  _frameHeight, RunLog &  _log  )

static

Definition at line 906 of file ScannerFile.cpp.

References CreateScannerFileForOutput(), ScannerFileFormatFromStr(), and sfUnKnown.

{
  ScannerFilePtr  scannerFile = NULL;

  Format  format = ScannerFileFormatFromStr (_formatStr);
  if  (format == Format::sfUnKnown)
  {
    _log.Level (-1) << endl << endl << "ScannerFile::CreateScannerFileForOutput  ***ERROR***   Invalid Format[" << _formatStr << "]" << endl << endl;
  }
  else
  {
    scannerFile = ScannerFile::CreateScannerFileForOutput
            (_fileName, (Format)format, _pixelsPerScanLine, _frameHeight, _log);
  }

  return  scannerFile;
}  /* CreateScannerFileForOutput */

void ScannerFile::DetermineFrameOffsetForFrame ( kkuint32  frameNum )

protected

Updates the byte offset for specified entry in 'frameOffsets' that is currently flagged with "-1".

This is meant to update entries in 'frameOffsets' that were flagged with '-1'. It will not work for frameNum == 0; this is okay since frameNum == 0 is updated when the scanner file is first opened. It is also assumed that the entry in frameOfsets just before 'frameNum' is already properly updated.

Definition at line 1178 of file ScannerFile.cpp.

References CreateGoalie(), KKB::GoalKeeper::EndBlock(), goalie, and KKB::GoalKeeper::StartBlock().

{
  if  ((frameNum < 1)  ||  (frameNum >= frameOffsets.size ()))
    return;

  CreateGoalie ();
  goalie->StartBlock ();

  FSeek (frameOffsets[frameNum - 1]);

  frameOffsets[frameNum] = SkipToNextFrame ();

  goalie->EndBlock ();
}  /* DetermineFrameOffsetForFrame */

bool KKLSC::ScannerFile::Eof ( ) const

inline

Definition at line 91 of file ScannerFile.h.

References eof.

{return  eof;}

void ScannerFile::ExtractHeaderField ( const KKStr &  fieldName, const KKStr &  fieldValue  )

protected

Definition at line 1058 of file ScannerFile.cpp.

References KKB::KKStr::EqualIgnoreCase(), flatFieldEnabled, frameHeight, pixelsPerScanLine, scanRate, KKB::KKStr::ToBool(), KKB::KKStr::ToFloat(), KKB::KKStr::ToInt(), and KKB::KKStr::ToInt32().

Referenced by AddHeaderField(), and ReadHeader().

{
  if  (fieldName.EqualIgnoreCase ("FrameHeight"))
  {
    kkuint32 fieldValueUint = fieldValue.ToInt32 ();
    if  ((fieldValueUint > 0)  &&  (fieldValueUint < (1024 * 1024)))
      frameHeight = fieldValue.ToInt32 ();
  }

  else if  (fieldName.EqualIgnoreCase ("PixelsPerScanLine"))
    pixelsPerScanLine = fieldValue.ToInt ();
  
  else if  (fieldName.EqualIgnoreCase ("ScanRate"))
    scanRate = fieldValue.ToFloat ();

  else if  (fieldName.EqualIgnoreCase ("FlatFieldCorrectionEnabled"))
    flatFieldEnabled = fieldValue.ToBool ();

}  /* ExtractHeaderField */

virtual Format KKLSC::ScannerFile::FileFormat ( ) const

inlinevirtual

Reimplemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, KKLSC::ScannerFileZLib3BitEncoded, and KKLSC::ScannerFileSimple.

Definition at line 78 of file ScannerFile.h.

References sfUnKnown.

Referenced by FileFormatStr(), and GetScannerFileParameters().

{return Format::sfUnKnown;}

KKStr ScannerFile::FileFormatStr

(

)

const

Definition at line 953 of file ScannerFile.cpp.

References FileFormat(), and ScannerFileFormatToStr().

Referenced by WriteHeader().

{
  return ScannerFile::ScannerFileFormatToStr (FileFormat ());
}

const KKStr& KKLSC::ScannerFile::FileName ( ) const

inline

Definition at line 92 of file ScannerFile.h.

References fileName.

Referenced by KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry().

{return  fileName;}

kkint64 KKLSC::ScannerFile::FileSizeInBytes ( ) const

inline

When opening a existing file represents size of file in Bytes.

Definition at line 93 of file ScannerFile.h.

References fileSizeInBytes.

bool KKLSC::ScannerFile::FlatFieldEnabled ( ) const

inline

Definition at line 94 of file ScannerFile.h.

References flatFieldEnabled.

{return  flatFieldEnabled;}

kkuint32 KKLSC::ScannerFile::FlowMeterCounter ( ) const

inline

Definition at line 95 of file ScannerFile.h.

References flowMeterCounter.

{return  flowMeterCounter;}

kkuint32 KKLSC::ScannerFile::FlowMeterCounterScanLine ( ) const

inline

Definition at line 96 of file ScannerFile.h.

References flowMeterCounterScanLine.

{return  flowMeterCounterScanLine;}

void ScannerFile::Flush ( )

virtual

Definition at line 227 of file ScannerFile.cpp.

References file.

{
  if  (file)
  {
    fflush (file);
  }
}

uchar* KKLSC::ScannerFile::FrameBuffer ( ) const

inline

Definition at line 98 of file ScannerFile.h.

References frameBuffer.

{return  frameBuffer;}

kkint64 KKLSC::ScannerFile::FrameBufferFileOffsetLast ( ) const

inline

Definition at line 100 of file ScannerFile.h.

References frameBufferFileOffsetLast.

{return  frameBufferFileOffsetLast;}

kkint64 KKLSC::ScannerFile::FrameBufferFileOffsetNext ( ) const

inline

Definition at line 101 of file ScannerFile.h.

References frameBufferFileOffsetNext.

{return  frameBufferFileOffsetNext;}

kkint32 KKLSC::ScannerFile::FrameHeight ( ) const

inline

Definition at line 97 of file ScannerFile.h.

References frameHeight.

Referenced by GetScannerFileParameters().

{return  frameHeight;}

bool KKLSC::ScannerFile::FrameOffsetsLoaded ( ) const

inline

Definition at line 99 of file ScannerFile.h.

References frameOffsetsLoaded.

{return  frameOffsetsLoaded;}

void ScannerFile::FrameRead	(	kkuint32	frameNum,
		bool &	found
	)

Read into frame buffer 'frameNum' and reposition so that next scan-line will be the 1st line in the frame.

The purpose of this method is to allow you to get whole frames at a time. Use the access method 'FrameBuffer' to get a pointer to the contents of the frame retrieved. The next call to 'GetNextLine' will return the first scan line in frame 'frameNum'.

Definition at line 500 of file ScannerFile.cpp.

References KKB::GoalKeeper::EndBlock(), frameBufferFileOffsetNext, frameBufferNextLine, frameBufferNumScanLines, frameHeight, frameNumCurLoaded, goalie, largestKnownScanLine, lastScanLine, nextScanLine, ReadBufferFrame(), KKB::GoalKeeper::StartBlock(), and UpdateFrameOffset().

Referenced by SkipToScanLine().

{
  if  (frameNum >= frameOffsets.size ())
  {
    found = false;
    return;
  }

  goalie->StartBlock ();
  FSeek (frameOffsets[frameNum]);

  frameBufferNumScanLines = ReadBufferFrame ();

  frameBufferNextLine = 0;
  frameBufferLastReadEof = (feof (file) != 0);
  frameNumCurLoaded = frameNum;

  if  (frameBufferNumScanLines > 1)
  {
    found = true;
    nextScanLine = frameNum * frameHeight;
    lastScanLine = nextScanLine - 1;
    kkint32  lastScanLineInFrame = nextScanLine + frameBufferNumScanLines - 1;
    if  (lastScanLineInFrame > largestKnownScanLine)
      largestKnownScanLine = lastScanLineInFrame;
    UpdateFrameOffset (frameNum + 1, (nextScanLine + frameHeight), frameBufferFileOffsetNext);
  }
  else
  {
    // Only time I can think this would happen is while reading the last frame;  meaning that the last frame
    // in the file has exactly 'frameHeight' scan lines.  This way when you read the next frame there are no scan lines.
    cerr << endl << "ScannerFile::FrameRead   ***ERROR***    No scan lines were loaded." << endl << endl;
  }
  goalie->EndBlock ();
}  /* FrameRead */

kkint32 ScannerFile::FSeek ( kkint64  filePos )

protected

Definition at line 1411 of file ScannerFile.cpp.

Referenced by BuildFrameOffsets().

{
  kkint32  returnCd = 0;
  returnCd = osFSEEK (file, filePos, SEEK_SET);
  return  returnCd;
}  /* FSeek */

kkint64 ScannerFile::GetFrameOffset ( kkuint32  frameNum )

protected

Definition at line 487 of file ScannerFile.cpp.

References KKB::GoalKeeper::EndBlock(), goalie, and KKB::GoalKeeper::StartBlock().

{
  kkint64  offset = -1;
  goalie->StartBlock ();
  if  (frameNum < frameOffsets.size ())
    offset = frameOffsets[frameNum];
  goalie->EndBlock ();
  return  offset;
}  /* GetFrameOffset */

void ScannerFile::GetNextLine ( uchar *  lineBuff, kkuint32  lineBuffSize, kkuint32 &  lineSize, kkuint32  colCount[], kkuint32 &  pixelsInRow  )

virtual

Definition at line 542 of file ScannerFile.cpp.

References KKB::GoalKeeper::EndBlock(), eof, frameBuffer, frameBufferFileOffsetNext, frameBufferLastReadEof, frameBufferNextLine, frameBufferNumScanLines, frameHeight, frameNumCurLoaded, goalie, largestKnownScanLine, lastScanLine, nextScanLine, pixelsPerScanLine, ReadBufferFrame(), KKB::GoalKeeper::StartBlock(), and UpdateFrameOffset().

{
  if  (eof)
    return;

  lastScanLine = nextScanLine;

  if  (frameBufferNextLine >= frameBufferNumScanLines)
  {
    if  (frameBufferLastReadEof)
    {
      eof = true;
      return;
    }     
    
    goalie->StartBlock ();
    frameBufferNumScanLines = ReadBufferFrame ();
    frameBufferNextLine = 0;
    frameBufferLastReadEof = (feof (file) != 0);

    if  ((frameBufferNumScanLines == 0) &&  frameBufferLastReadEof)
    {
      // We already are at EOF.
      eof = true;
      return;
    }

    if  (frameBufferNumScanLines > 0)
    {
      frameNumCurLoaded = nextScanLine / frameHeight;
      kkint32  lastScanLineInFrame = nextScanLine + frameBufferNumScanLines - 1;
      if  (lastScanLineInFrame > largestKnownScanLine)
        largestKnownScanLine = lastScanLineInFrame;
      UpdateFrameOffset (frameNumCurLoaded, nextScanLine, frameBufferFileOffsetNext);
    }
    else
    {
      // There were no scan lines loaded.
      cerr << endl << "ScannerFile::GetNextLine   ***ERROR***   No scan lines loaded." << endl << endl;
    }
    goalie->EndBlock ();
  }

  kkuint32  frameBufferOffset = frameBufferNextLine * pixelsPerScanLine;

  lineSize= 0;
  kkuint32  bytesToCopy = Min (lineBuffSize, pixelsPerScanLine);
  for  (kkuint32 x = 0;  x < bytesToCopy;  ++x)
  {
    uchar  pixel = frameBuffer[frameBufferOffset];
    lineBuff[x] = pixel;
    if  (pixel > 0)
    {
      colCount[x] += 1;
      ++pixelsInRow;
    }
    ++lineSize;
    ++frameBufferOffset;
  }

  ++frameBufferNextLine;
  ++nextScanLine;
}  /* GetNextLine */

void ScannerFile::GetScannerFileParameters ( const KKStr &  _scannerFileName, ScannerHeaderFieldsPtr &  _headerFields, Format &  _scannerFileFormat, kkint32 &  _frameHeight, kkint32 &  _frameWidth, float &  _scanRate, bool &  _successful, RunLog &  _log  )

static

Retrieves statistics for a specified Scanner File.

Will read the header information for the specified scanner file to retrieve parameters.

Parameters

[in]	_scannerFileName	Name of scanner file that you want to retrieve parameters for.
[out]	_headerFields	Copy of header fields from Scanner File; caller will own them and be responsible for deleting them; if != NULL upon call previous instance will be deleted.
[out]	_scannerFileFormat	Format of scanner file; ex: sf3BitEncoded.
[out]	_frameHeight	Frame height of source camera.
[out]	_frameWidth	Width in pixels of scanner file.
[out]	_scanRate	Scan lines/sec that imagery was acquired at.
[out]	_successful	Indicates if successful in retrieving parameters.
[in,out]	_log	Log file.

Definition at line 754 of file ScannerFile.cpp.

References CreateScannerFile(), FileFormat(), FrameHeight(), HeaderFields(), PixelsPerScanLine(), KKLSC::ScannerHeaderFields::ScannerHeaderFields(), and ScanRate().

{
  _successful = false;
  ScannerFilePtr  sf = CreateScannerFile (_scannerFileName, _log);
  if  (sf == NULL)
  {
    _log.Level (-1) << "Could not determine scanner file format." << endl;
    return;
  }

  delete  _headerFields;
  _headerFields = new ScannerHeaderFields (*(sf->HeaderFields ()));
  _scannerFileFormat = sf->FileFormat        ();
  _frameHeight       = sf->FrameHeight       ();
  _frameWidth        = sf->PixelsPerScanLine ();
  _scanRate          = sf->ScanRate          ();

  _successful = true;
  delete  sf;
  sf = NULL;
}  /* GetScannerFileParameters */

const KKStr & ScannerFile::GetValue

(

const KKStr &

fieldName

)

Definition at line 1107 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::EmptyStr(), KKLSC::ScannerHeaderFields::GetValue(), and headerFields.

{
  if  (!headerFields)
    return KKStr::EmptyStr ();
  else
    return headerFields->GetValue (fieldName);
}

float ScannerFile::GetValueFloat

(

const KKStr &

fieldName

)

Definition at line 1116 of file ScannerFile.cpp.

References KKLSC::ScannerHeaderFields::GetValueFloat(), and headerFields.

{
  if  (!headerFields)
    return 0.0f;
  else
    return headerFields->GetValueFloat (fieldName);
}

ScannerFile::Format ScannerFile::GuessFormatOfFile ( const KKStr &  _fileName, RunLog &  _log  )

static

Definition at line 729 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKB::KKStr::ExtractToken2(), KKB::KKStr::KKStr(), KKB::osFOPEN(), ReadHeaderOneLine(), ScannerFileFormatFromStr(), sfUnKnown, and KKB::KKStr::Str().

Referenced by CreateScannerFile().

{
  // Will guess what file format by trying to open each one until one is considered valid.

  FILE*  f = osFOPEN (_fileName.Str (), "rb");
  if  (!f)
    return Format::sfUnKnown;

  bool  endOfText = false;
  KKStr ln (100);
  ReadHeaderOneLine (f, endOfText, ln);
  fclose (f);

  KKStr fieldName = ln.ExtractToken2 ("\t");
  if  (!fieldName.EqualIgnoreCase ("ScannerFile"))
    return Format::sfUnKnown;

  KKStr  scannerFileFormatStr = ln.ExtractToken2 ("\t");
  return  ScannerFileFormatFromStr (scannerFileFormatStr);
}  /*  GuessFormatOfFile */

ScannerHeaderFieldsPtr KKLSC::ScannerFile::HeaderFields ( ) const

inline

Definition at line 102 of file ScannerFile.h.

References headerFields.

Referenced by GetScannerFileParameters().

{return  headerFields;}

void ScannerFile::InitiateWritting

(

)

Definition at line 976 of file ScannerFile.cpp.

References AddHeaderField(), byteOffsetScanLineZero, file, frameBufferFileOffsetLast, frameBufferFileOffsetNext, frameHeight, lastScanLine, nextScanLine, KKB::osFTELL(), pixelsPerScanLine, scanRate, KKB::StrFormatDouble(), KKB::StrFormatInt(), UpdateFrameOffset(), and WriteHeader().

{
  AddHeaderField ("ScanRate",          StrFormatDouble (scanRate,          "##0.00"));
  AddHeaderField ("PixelsPerScanLine", StrFormatInt    (pixelsPerScanLine, "#####0"));
  AddHeaderField ("FrameHeight",       StrFormatInt    (frameHeight,       "#####0"));
  WriteHeader ();

  lastScanLine = 0;
  nextScanLine = 0;
  frameBufferFileOffsetLast = -1;
  frameBufferFileOffsetNext = osFTELL (file);
  byteOffsetScanLineZero = frameBufferFileOffsetNext;
  UpdateFrameOffset (0, 0, byteOffsetScanLineZero);
}  /* InitiateWritting */

kkint32 KKLSC::ScannerFile::LargestKnowmFrameNum ( ) const

inline

Definition at line 103 of file ScannerFile.h.

{return  ((kkint32)frameOffsets.size () - 1);}

kkint32 KKLSC::ScannerFile::LargestKnownScanLine ( ) const

inline

Definition at line 104 of file ScannerFile.h.

References largestKnownScanLine.

{return  largestKnownScanLine;}

kkint32 KKLSC::ScannerFile::LastScanLine ( ) const

inline

Last Scan-line read or written.

Definition at line 105 of file ScannerFile.h.

References lastScanLine.

void ScannerFile::LoadIndexFile

(

bool &

successful

)

Call this method to Load the FrameOffsets and StartStop points from the index file.

This method is also called from 'BuildFrameOffsets',

Definition at line 1323 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), eof, KKB::KKStr::EqualIgnoreCase(), KKB::KKStr::ExtractToken2(), KKB::KKStr::ExtractTokenInt(), KKB::KKStr::ExtractTokenUint(), KKB::KKStr::ExtractTokenUint64(), fileName, indexFile, indexFileName, KKLSC::StartStopPoint::Invalid, largestKnownScanLine, KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::osFOPEN(), KKB::osReadRestOfLine(), KKB::osRemoveExtension(), KKLSC::StartStopPoint::StartStopPoint(), KKB::KKStr::Str(), KKLSC::StartStopPoint::Type(), and UpdateFrameOffset().

Referenced by BuildFrameOffsets().

{
  if  (indexFile)
  {
    delete  indexFile;
    indexFile = NULL;
  }

  indexFileName = osRemoveExtension (fileName) + ".idx";
  FILE* f = osFOPEN (indexFileName.Str (), "r");

  if  (!f)
  {
    log.Level (-1) << "LoadIndexFile  IndexFile[" << indexFileName << "] does not exist." << endl;
    successful = false;
    return;
  }

  KKStrPtr  ln = NULL;

  while  (true)
  {
    bool  eol = false;
    delete ln;
    ln = KKB::osReadRestOfLine (f, eof);
    if  (eof)  break;
    if  (!ln)  continue;

    KKStr lineName = ln->ExtractToken2 ("\t\n\r");

    if  (lineName.EqualIgnoreCase ("IndexEntry"))
    {
      kkuint32 frameNum    = ln->ExtractTokenUint   ("\t\n\r");
      kkint32  scanLineNum = ln->ExtractTokenInt    ("\t\n\r");
      kkuint64 byteOffset  = ln->ExtractTokenUint64 ("\t\n\r");
      UpdateFrameOffset (frameNum, scanLineNum, byteOffset);
      if  (scanLineNum > largestKnownScanLine)
        largestKnownScanLine = scanLineNum;
    }

    else if  (lineName.EqualIgnoreCase ("ClearStartStopPoints"))
    {
      startStopPoints.Clear ();
    }

    else if  (lineName.EqualIgnoreCase ("StartStopPoint"))
    {
      StartStopPointPtr  entry = new StartStopPoint (*ln);
      if  (entry->Type () == StartStopPoint::StartStopType::Invalid)
      {
        delete  entry;
        entry = NULL;
      }
      else
      {
        startStopPoints.AddEntry (entry);
      }
    }

    else if  (lineName.EqualIgnoreCase ("DeleteStartStopPoint"))
    {
      kkint32  scanLineNum = ln->ExtractTokenInt ("\n\t\r");
      startStopPoints.DeleteEntry (scanLineNum);
    }
  }
  delete  ln;
  ln = NULL;

  fclose (f);
  successful = true;
}  /* LoadIndexFile */

kkint32 ScannerFile::MemoryConsumedEstimated ( ) const

virtual

Definition at line 177 of file ScannerFile.cpp.

References file, frameBuffer, frameBufferSize, headerFields, indexFile, KKLSC::ScannerHeaderFields::MemoryConsumedEstimated(), KKLSC::ScannerFileEntry::MemoryConsumedEstimated(), and scannerFileEntry.

{
  kkint32  mem = sizeof (*this) + 
               fileName.MemoryConsumedEstimated ()       +
               frameOffsets.size () * sizeof(kkint64)    +
               indexFileName.MemoryConsumedEstimated ()  +
               startStopPoints.MemoryConsumedEstimated ();

  if  (file)              mem += 2000;
  if  (headerFields)      mem += headerFields->MemoryConsumedEstimated ();
  if  (frameBuffer)       mem += frameBufferSize;
  if  (indexFile)         mem += 2000;
  if  (scannerFileEntry)  mem += scannerFileEntry->MemoryConsumedEstimated ();
  return  mem;
}

kkint32 KKLSC::ScannerFile::NextScanLine ( ) const

inline

Next scan-line to be read.

Definition at line 106 of file ScannerFile.h.

References nextScanLine.

void ScannerFile::Open ( const KKStr &  _fileName )

protected

Definition at line 265 of file ScannerFile.cpp.

References eof, file, fileName, fileSizeInBytes, indexFileName, ioMode, ioRead, opened, KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::osFOPEN(), KKB::osGetFileSize(), KKB::osRemoveExtension(), and KKB::KKStr::Str().

Referenced by ScannerFile().

{
  eof = false;
  fileName = _fileName;
  fileSizeInBytes = 0;

  if  (ioMode == ioRead)
  {
    file = osFOPEN (fileName.Str (), "rb");
    if  (file)
      fileSizeInBytes = osGetFileSize (fileName);
  }
  else
  {
    file = osFOPEN (fileName.Str (), "wb");
    indexFileName = osRemoveExtension (_fileName) + ".idx";
    indexFile = new ofstream (indexFileName.Str ());
    *indexFile << "IndexFile"                                      << endl
               << "ScannerFile" << "\t" << _fileName               << endl
               << "DateTime"    << "\t" << osGetLocalDateTime ()   << endl;

    *indexFile << "IndexEntryFields" << "\t" << "FrameNum"
                                     << "\t" << "ScanLineNum"
                                     << "\t" << "ByteOffset"
                                     << endl;
  }

  if  (file)
  {
    opened = true;
  }
  else
  {
    opened = false;
    log.Level (-1) << endl << endl << "ScannerFile::Open     ***ERROR***   Opening File[" << fileName << "]" << endl << endl;
  }
}  /* Open */

bool KKLSC::ScannerFile::Opened ( ) const

inline

Definition at line 107 of file ScannerFile.h.

References opened.

{return  opened;}

kkuint32 KKLSC::ScannerFile::PixelsPerScanLine ( ) const

inline

Definition at line 108 of file ScannerFile.h.

References pixelsPerScanLine.

Referenced by KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry(), and GetScannerFileParameters().

{return  pixelsPerScanLine;}

virtual kkuint32 KKLSC::ScannerFile::ReadBufferFrame ( )

protectedpure virtual

Read in one Scanner File Frame return number of actual scan-lines read.

Unless end of file is reached this method will read in 'framHeight' scan-lines.

Implemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, and KKLSC::ScannerFileSimple.

Referenced by FrameRead(), GetNextLine(), and SkipNextLine().

void ScannerFile::ReadHeader ( )

protected

Definition at line 1037 of file ScannerFile.cpp.

References KKLSC::ScannerHeaderFields::Add(), KKB::KKStr::Concat(), ExtractHeaderField(), KKB::KKStr::ExtractToken2(), file, headerFields, KKB::KKStr::KKStr(), ReadHeaderOneLine(), and KKLSC::ScannerHeaderFields::ScannerHeaderFields().

Referenced by Reset(), and ScannerFile().

{
  delete  headerFields;
  headerFields = new ScannerHeaderFields ();
  bool  endOfText = false;
  KKStr  ln (100);

  ReadHeaderOneLine (file, endOfText, ln);
  while  (!endOfText)
  {
    KKStr  fieldName   = ln.ExtractToken2 ("\t");
    KKStr  fieldValue  = ln.ExtractToken2 ("\t");
    headerFields->Add (fieldName, fieldValue);
    ExtractHeaderField (fieldName, fieldValue);
    ReadHeaderOneLine (file, endOfText, ln);
  }
}  /* ReadHeader */

void ScannerFile::ReadHeaderOneLine ( FILE *  f, bool &  endOfText, KKStr &  line  )

staticprotected

Definition at line 1015 of file ScannerFile.cpp.

References KKB::KKStr::Append(), and KKB::KKStr::operator=().

Referenced by GuessFormatOfFile(), and ReadHeader().

{
  char  ch;
  line = "";
  endOfText = false;

  kkint32  bytesReturned = fread (&ch, 1, 1, f);
  while  ((ch != 0)  &&  (ch != '\n')  &&  (bytesReturned > 0))
  {
    line.Append (ch);
    bytesReturned = fread (&ch, 1, 1, f);
  }

  if  ((ch == 0)  ||  (bytesReturned == 0))
    endOfText = true;
}  /* ReadHeaderOneLine */

VectorFloatPtr ScannerFile::RecordRateByTimeIntervals

(

int

intervalSecs

)

Returns an array indication the record rate in bytes/sec for specified time-intervals.

Each element in the returned array will give the average number of bytes recorded for the time the corresponding time interval. Array element 0 starts at the beginning of the Scanner file and covers the number of scan lines required to account for 'intervalSecs' seconds.

Definition at line 402 of file ScannerFile.cpp.

References frameHeight, and scanRate.

{
  float  secsPerFrame = 1.0f;
  if  (scanRate > 0.0f)
    secsPerFrame = frameHeight  / scanRate;
  else
    secsPerFrame = frameHeight  / 5000.0f;  // Assume 5k ScanLines per second

  float  totalTime = (float)(frameOffsets.size ()) * secsPerFrame;
  int  totalNumIntervals = (int)(0.5f + totalTime / (float)intervalSecs);

  VectorFloatPtr  recordRates = new VectorFloat (totalNumIntervals, 0.0f);
  int  idx = 0;

  kkuint32 frameOffsetsIdx = 0;
  kkint64  bytesThisFrame = frameOffsets[frameOffsetsIdx];
  float    frameOffsetsStartTime = 0;
  float    frameOffsetsEndTime   = secsPerFrame;
  float    frameOffsetsRecRate = (float)bytesThisFrame / secsPerFrame;

  while  (idx <  totalNumIntervals)
  {
    float  timeIntervalStartTime = (float)(idx * intervalSecs);
    float  timeIntervalEndTime   = timeIntervalStartTime + (float)intervalSecs;

    float  timeIntervalCurTime = timeIntervalStartTime;
    while  (timeIntervalCurTime < timeIntervalEndTime)
    {
      float  nextMark = Min (timeIntervalEndTime, frameOffsetsEndTime);
      float  deltaTime = nextMark - timeIntervalCurTime;
      (*recordRates)[idx] += frameOffsetsRecRate *  (deltaTime / secsPerFrame);
      timeIntervalCurTime = nextMark;

      ++frameOffsetsIdx;
      frameOffsetsStartTime = frameOffsetsIdx * secsPerFrame;
      frameOffsetsEndTime = frameOffsetsStartTime + (float)secsPerFrame;
      if  (frameOffsetsIdx < frameOffsets.size ())
        bytesThisFrame = frameOffsets[frameOffsetsIdx] - frameOffsets[frameOffsetsIdx - 1];
      else
        bytesThisFrame  = 0;
      frameOffsetsRecRate = (float)bytesThisFrame / secsPerFrame;
    }
    ++idx;
  }

  return  recordRates;
}  /* RecordRateByTimeIntervals */

void ScannerFile::ReportInstrumentDataWord ( uchar  idNum, kkuint32  scanLineNum, WordFormat32Bits  dataWord  )

protected

Todo:

Need to add code to do something the data word just posted.

Definition at line 1152 of file ScannerFile.cpp.

References flowMeterCounter, flowMeterCounterScanLine, and KKB::WordFormat32Bits::unsigned32BitInt.

Referenced by ReportTextMsg().

{
  /**
   *@todo  Need to add code to do something the data word just posted.
   */

  if  (idNum == 0)
  {
    // This is the FlowMeterCounter field,
    flowMeterCounter = dataWord.unsigned32BitInt;
    flowMeterCounterScanLine = scanLineNum;
  }
}  /* ReportInstrumentDataWord */

void ScannerFile::ReportTextMsg ( const char *  textBuff, kkint32  numTextBytes  )

protected

Text messages that are embedded in a scanner file can be reported here.

If a derived class/format of 'ScannerFile' contains Text messages, that class would call this method with the embedded text message. Possible uses of this would be instrumentation data such as that produced by CTD.

Todo:

Need to add code to do something with the textBuff message.

Definition at line 1126 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::ExtractToken2(), KKB::KKStr::ExtractTokenInt(), KKB::KKStr::ExtractTokenUint(), KKB::KKStr::KKStr(), ReportInstrumentDataWord(), KKB::KKStr::StartsWith(), and KKB::WordFormat32Bits::WordFormat32Bits().

{
  KKStr  s (textBuff, 0, numTextBytes - 1);
  if  (s.StartsWith ("InstrumentDataWord\t", true))
  {
    s.ExtractToken2 ("\t");
    kkint32  idNum = s.ExtractTokenInt ("\t");
    kkuint32 scanLineNum = s.ExtractTokenUint ("\t");
    kkuint32 dataWord = s.ExtractTokenUint ("\t");
    WordFormat32Bits  w (dataWord);
    ReportInstrumentDataWord (idNum, scanLineNum, w);
  }
  else
  {
    /**
     *@todo  Need to add code to do something with the textBuff message.
     */
  }
}  /* ReportTextMsg */

void ScannerFile::Reset

(

)

Definition at line 246 of file ScannerFile.cpp.

References eof, file, frameBufferFileOffsetLast, frameBufferFileOffsetNext, frameBufferLastReadEof, lastScanLine, nextScanLine, opened, KKB::osFTELL(), and ReadHeader().

{
  if  (!opened)
    return;

  eof = false;  
  rewind (file);
  ReadHeader ();

  frameBufferLastReadEof = false;
  lastScanLine = 0;
  nextScanLine = 0;
  frameBufferFileOffsetLast = -1;
  frameBufferFileOffsetNext = osFTELL (file);
}  /* Reset */

void ScannerFile::SaveIndexFile ( std::vector< kkint64 > &  frameOffsets )

protected

Definition at line 1292 of file ScannerFile.cpp.

References fileName, indexFileName, KKB::KKStr::operator+(), KKB::KKStr::operator=(), and KKB::osRemoveExtension().

{
  indexFileName = osRemoveExtension (fileName) + ".idx";
  ofstream f (indexFileName.Str ());
  f << "IndexFile"                                     << endl
    << "ScannerFile" << "\t" << fileName               << endl
    << "DateTime"    << "\t" << osGetLocalDateTime ()  << endl;

  f << "IndexEntryFields" << "\t" << "FrameNum"
                          << "\t" << "ScanLineNum"
                          << "\t" << "ByteOffset"
                          << endl;

  for  (kkuint32 frameNum = 0;  frameNum < frameOffsets.size ();  ++frameNum)
  {
    f << "IndexEntry" << "\t" << frameNum << "\t" << (frameNum * frameHeight) << "\t" << frameOffsets[frameNum] << endl;
  }

  StartStopPointList::const_iterator  idx;
  for  (idx = startStopPoints.begin ();  idx != startStopPoints.end ();  ++idx)
  {
    StartStopPointPtr ssp = *idx;
    f << "StartStopPoint" << "\t" << ssp->ToTabDelStr () << endl;
  }

  f.close ();
}  /* SaveIndexFile */

ScannerFile::Format ScannerFile::ScannerFileFormatFromStr ( const KKStr &  fileFormatStr )

static

Definition at line 961 of file ScannerFile.cpp.

References KKB::KKStr::EqualIgnoreCase(), fileFormatOptions, and sfUnKnown.

Referenced by CreateScannerFileForOutput(), and GuessFormatOfFile().

{
  kkint32  x = 0;
  while  (x < (kkint32)Format::sfUnKnown)
  {
    if  (fileFormatStr.EqualIgnoreCase (fileFormatOptions[x]))
      return (Format)x;
    ++x;
  }

  return  Format::sfUnKnown;
}  /* ScannerFileFormatFromStr */

const KKStr & ScannerFile::ScannerFileFormatToStr ( Format  fileFormat )

static

Definition at line 943 of file ScannerFile.cpp.

References fileFormatOptions, and sfUnKnown.

Referenced by FileFormatStr().

{
  if  (((int)fileFormat < 0)  ||  (fileFormat >= Format::sfUnKnown))
    return fileFormatOptions[(int)Format::sfUnKnown];
  else
    return fileFormatOptions[(int)fileFormat];
}  /* ScannerFileFormatToStr */

float KKLSC::ScannerFile::ScanRate ( ) const

inline

Definition at line 109 of file ScannerFile.h.

References scanRate.

Referenced by KKLSC::ScannerFileEntry::GetOrCreateScannerFileEntry(), and GetScannerFileParameters().

{return  scanRate;}

void ScannerFile::ScanRate ( float  _scanRate )

virtual

Reimplemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, and KKLSC::ScannerFileZLib3BitEncoded.

Definition at line 238 of file ScannerFile.cpp.

References scanRate.

{
  scanRate = _scanRate;
}

void ScannerFile::SkipBytesForward ( kkuint32  numBytes )

protected

Definition at line 1398 of file ScannerFile.cpp.

{
  kkint32  returnCd = osFSEEK (file, numBytes, SEEK_CUR);
  if  (returnCd != 0)
  {
    log.Level (-1) << "ScannerFile::SkipBytesForward   ReturnCd = " << returnCd << endl;
  }
}  /* SkipBytesForward */

void ScannerFile::SkipNextLine

(

)

Definition at line 615 of file ScannerFile.cpp.

References KKB::GoalKeeper::EndBlock(), eof, frameBufferFileOffsetNext, frameBufferLastReadEof, frameBufferNextLine, frameBufferNumScanLines, frameHeight, frameNumCurLoaded, goalie, largestKnownScanLine, lastScanLine, nextScanLine, ReadBufferFrame(), KKB::GoalKeeper::StartBlock(), and UpdateFrameOffset().

{
  if  (eof)
    return;

  lastScanLine = nextScanLine;

  if  (frameBufferNextLine >= frameBufferNumScanLines)
  {
    if  (frameBufferLastReadEof)
    {
      eof = true;
      return;
    }     
    
    goalie->StartBlock ();
    frameBufferNumScanLines = ReadBufferFrame ();
    frameBufferNextLine = 0;
    frameBufferLastReadEof = (feof (file) != 0);

    if  (frameBufferNumScanLines > 0)
    {
      frameNumCurLoaded = nextScanLine / frameHeight;
      kkint32  lastScanLineInFrame = nextScanLine + frameBufferNumScanLines - 1;
      if  (lastScanLineInFrame > largestKnownScanLine)
        largestKnownScanLine = lastScanLineInFrame;
      UpdateFrameOffset (frameNumCurLoaded, nextScanLine, frameBufferFileOffsetNext);
    }
    else
    {
      cerr << endl << "ScannerFile::SkipNextLine   ***ERROR***     No scan lines were loaded." << endl << endl;
    }
    goalie->EndBlock ();
  }

  ++frameBufferNextLine;
  ++nextScanLine;
}  /* SkipNextLine */

virtual kkint64 KKLSC::ScannerFile::SkipToNextFrame ( )

protectedpure virtual

Skip to start of next frame returning back byte offset of that frame.

This will be called by the 'UpdateFrameOffset' and 'DetermineFrameOffsetForFrame' methods used to build the 'frameOffsets' table. It is important that the implementation of this method NOT update the frameBuffer fields; such as 'frameBuffer', 'frameBufferNextLine', etc .....

Implemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, and KKLSC::ScannerFileSimple.

Referenced by BuildFrameOffsets().

void ScannerFile::SkipToScanLine

(

kkint32

scanLine

)

Repositions the file such that the next call to 'GetNextLine' returns the 'scanLine' scan-line.

This method depends on the table'frameOffsets'; it will compute the frame number from the scan line and use the appropriate entry in 'frameOffsets' to start reading from the beginning of the frame that contains 'scanLine'. If you select a 'scanLine' that is beyond the known number of scan lines in the scanner file (see largestKnownScanLine) the eof flag will be set to 'true'.

Parameters

[in]

scanLine

Scan line to skip to so that the next call to 'GetNextLine' retrieves it.

Definition at line 682 of file ScannerFile.cpp.

References eof, frameBufferNextLine, frameBufferNumScanLines, frameHeight, frameNumCurLoaded, FrameRead(), lastScanLine, and nextScanLine.

{
  kkuint32  frameNum = scanLine / frameHeight;
  if  (frameNum >= frameOffsets.size ())
    frameNum = frameOffsets.size () - 1;

  if  (frameNum != frameNumCurLoaded)
  {
    bool found = false;
    FrameRead (frameNum, found);
    if  (!found)
    {
      eof = true;
      return;
    }
  }

  frameBufferNextLine = scanLine % frameHeight;
  if  (frameBufferNextLine > frameBufferNumScanLines)
  {
    // I believe that the only way that this could happen is if 'frameNum' is the last frame in the file.
    cerr << endl << endl << "ScannerFile::SkipToScanLine   ***ERROR***   FrameBufer is short scan lines." << endl << endl;
  }

  lastScanLine = scanLine - 1;
  nextScanLine = scanLine;
}  /* SkipToScanLine */

void ScannerFile::StartStopPointDelete

(

kkint32

_scanLineNum

)

Definition at line 371 of file ScannerFile.cpp.

References AddStartStopEntryToIndexFile(), and KKLSC::StartStopPoint::StopPoint.

{
  startStopPoints.DeleteEntry (_scanLineNum);
  AddStartStopEntryToIndexFile (_scanLineNum, StartStopPoint::StartStopType::StopPoint, true);
}

StartStopPointPtr ScannerFile::StartStopPointNearestEntry

(

kkint32

_scanLineNum

)

Definition at line 380 of file ScannerFile.cpp.

{
  return  startStopPoints.NearestEntry (_scanLineNum);
}

StartStopPointPtr ScannerFile::StartStopPointPrevEntry

(

kkint32

_scanLineNum

)

Definition at line 387 of file ScannerFile.cpp.

{
  return  startStopPoints.PrevEntry (_scanLineNum);
}

const StartStopPointList& KKLSC::ScannerFile::StartStopPoints ( ) const

inline

Definition at line 134 of file ScannerFile.h.

{return startStopPoints;}

StartStopPointPtr ScannerFile::StartStopPointSuccEntry

(

kkint32

_scanLineNum

)

Definition at line 394 of file ScannerFile.cpp.

{
  return  startStopPoints.SuccEntry (_scanLineNum);
}

void ScannerFile::UpdateFrameOffset ( kkuint32  frameNum, kkuint32  scanLineNum, kkint64  byteOffset  )

protected

Definition at line 456 of file ScannerFile.cpp.

References CreateGoalie(), KKB::GoalKeeper::EndBlock(), goalie, and KKB::GoalKeeper::StartBlock().

Referenced by FrameRead(), GetNextLine(), InitiateWritting(), LoadIndexFile(), ScannerFile(), SkipNextLine(), and WriteScanLine().

{
  CreateGoalie ();
  goalie->StartBlock ();

  if  (frameNum == frameOffsets.size ())
  {
    frameOffsets.push_back (byteOffset);
  }
  else if  (frameNum < frameOffsets.size ())
  {
    frameOffsets[frameNum] = byteOffset;
  }
  else
  {
    while  (frameOffsets.size () < frameNum)
      frameOffsets.push_back (-1);
    frameOffsets.push_back (byteOffset);
  }

  if  (indexFile)
    *indexFile << "IndexEntry" << "\t" << frameNum << "\t" << scanLineNum << "\t" << byteOffset << endl;

  goalie->EndBlock ();
}  /* UpdateFrameOffset */

virtual void KKLSC::ScannerFile::WriteBufferFrame ( )

protectedpure virtual

Write the contents of 'frameBuffer' to he end of the scanner file.

Will write the entire contents of 'frameBuffer' to the end of the scanner file.

Implemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, and KKLSC::ScannerFileSimple.

Referenced by Close(), and WriteScanLine().

void ScannerFile::WriteHeader ( )

protected

This method is called before any scanner data is added to the file. It will write the header information for the file.

Definition at line 993 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), FileFormatStr(), headerDataWritten, KKB::KKStr::KKStr(), and KKB::KKStr::operator=().

Referenced by InitiateWritting().

{
  KKStr  ln (100);
  ln << "ScannerFile" << "\t" << FileFormatStr () << "\n";
  fwrite (ln.Str (), 1, ln.Len (), file);
  
  ScannerHeaderFields::const_iterator  idx;
  for  (idx = headerFields->begin ();  idx != headerFields->end ();  ++idx)
  {
    ln = "";
    ln << idx->first << "\t" << idx->second << "\n";
    fwrite (ln.Str (), 1, ln.Len (), file);
  }

  // Write End of text Marker
  char  ch = 0;
  fwrite (&ch, 1, 1, file);
  headerDataWritten = true;
}  /* WriteHeader */

void ScannerFile::WriteInstrumentDataWord ( uchar  idNum, kkuint32  scanLineNum, WordFormat32Bits  dataWord  )

virtual

Writes a 32 bit number into the Scanner File Stream at current location.

Adds Instrument data to the underlying Scanner files as text.

Parameters

[in]	idNum	nNumber that identifies Instrument data, ex: 0 is reserved for Flow Meter Count.
[in]	scanLineNum	Scan-line that 'dataWord' occurred at.
[in]	dataWord	32 bit number being written.

Definition at line 715 of file ScannerFile.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKB::KKStr::Str(), KKB::WordFormat32Bits::unsigned32BitInt, and WriteTextBlock().

{
  KKStr  s (100);
  s << "InstrumentDataWord" << "\t" << (int)idNum << "\t" << scanLineNum << "\t" << dataWord.unsigned32BitInt;
  WriteTextBlock ((const uchar*)s.Str (), s.Len ());
}  /* WriteInstrumentDataWord */

void ScannerFile::WriteScanLine ( const uchar *  buffer, kkuint32  bufferLen  )

virtual

Definition at line 657 of file ScannerFile.cpp.

References frameBufferFileOffsetNext, frameBufferNextLine, frameHeight, frameNumCurLoaded, lastScanLine, nextScanLine, pixelsPerScanLine, UpdateFrameOffset(), and WriteBufferFrame().

{
  lastScanLine = nextScanLine;

  if  (frameBufferNextLine >= frameHeight)
  {
    WriteBufferFrame ();
    frameBufferNextLine = 0;
    frameNumCurLoaded = nextScanLine / frameHeight;
    UpdateFrameOffset (frameNumCurLoaded, nextScanLine, frameBufferFileOffsetNext);
  }

  kkuint32  byteOffset = (frameBufferNextLine * pixelsPerScanLine);
  kkuint32  bytesToCopy = Min (bufferLen, pixelsPerScanLine);
  memcpy (frameBuffer + byteOffset, buffer, bytesToCopy);
  
  ++nextScanLine;
  ++frameBufferNextLine;
}  /* WriteScanLine */

virtual void KKLSC::ScannerFile::WriteTextBlock ( const uchar *  txtBlock, kkuint32  txtBlockLen  )

pure virtual

Implemented in KKLSC::ScannerFile4BitEncoded, KKLSC::ScannerFile3BitEncoded, KKLSC::ScannerFile2BitEncoded, and KKLSC::ScannerFileZLib3BitEncoded.

Referenced by WriteInstrumentDataWord().

Member Data Documentation

kkint64 KKLSC::ScannerFile::byteOffsetScanLineZero

protected

Byte offset of 1st scan line after the header fields.

Definition at line 392 of file ScannerFile.h.

Referenced by ByteOffsetScanLineZero(), InitiateWritting(), and ScannerFile().

bool KKLSC::ScannerFile::eof

protected

Definition at line 393 of file ScannerFile.h.

Referenced by Eof(), GetNextLine(), LoadIndexFile(), Open(), Reset(), ScannerFile(), SkipNextLine(), and SkipToScanLine().

FILE* KKLSC::ScannerFile::file

protected

Definition at line 394 of file ScannerFile.h.

Referenced by BuildFrameOffsets(), Close(), Flush(), InitiateWritting(), MemoryConsumedEstimated(), Open(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), ReadHeader(), Reset(), ScannerFile(), KKLSC::ScannerFileSimple::SkipToNextFrame(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), KKLSC::ScannerFileZLib3BitEncoded::WriteTextBlock(), KKLSC::ScannerFile2BitEncoded::WriteTextBlock(), KKLSC::ScannerFile3BitEncoded::WriteTextBlock(), and KKLSC::ScannerFile4BitEncoded::WriteTextBlock().

const KKStr ScannerFile::fileFormatOptions

staticprotected

Initial value:

= {"Simple",
       "2BitEncoded",
       "3BitEncoded",
       "4BitEncoded",
       "Zlib3BitEncoded",
       "UnKnown"
      }

Definition at line 363 of file ScannerFile.h.

Referenced by ScannerFileFormatFromStr(), and ScannerFileFormatToStr().

KKStr KKLSC::ScannerFile::fileName

protected

Definition at line 395 of file ScannerFile.h.

Referenced by CreateGoalie(), FileName(), LoadIndexFile(), Open(), SaveIndexFile(), and ScannerFile().

kkint64 KKLSC::ScannerFile::fileSizeInBytes

protected

Definition at line 396 of file ScannerFile.h.

Referenced by FileSizeInBytes(), Open(), ScannerFile(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), KKLSC::ScannerFileZLib3BitEncoded::WriteTextBlock(), KKLSC::ScannerFile2BitEncoded::WriteTextBlock(), KKLSC::ScannerFile3BitEncoded::WriteTextBlock(), and KKLSC::ScannerFile4BitEncoded::WriteTextBlock().

bool KKLSC::ScannerFile::flatFieldEnabled

protected

Indicates if Flat-Field-Correction was enabled when file recorded.

Definition at line 397 of file ScannerFile.h.

Referenced by ExtractHeaderField(), FlatFieldEnabled(), and ScannerFile().

kkuint32 KKLSC::ScannerFile::flowMeterCounter

protected

Updated while reading Scanner Files; whenever InstrumentID == 0 is read this field will be updated along with 'flowMeterCounterScanLineNum'.

Definition at line 412 of file ScannerFile.h.

Referenced by FlowMeterCounter(), ReportInstrumentDataWord(), and ScannerFile().

kkuint32 KKLSC::ScannerFile::flowMeterCounterScanLine

protected

Represents the scan line that 'flowMeterCounter' was last updated for while reading a Scanner File.

Definition at line 416 of file ScannerFile.h.

Referenced by FlowMeterCounterScanLine(), ReportInstrumentDataWord(), and ScannerFile().

uchar* KKLSC::ScannerFile::frameBuffer

protected

Raw scanner data will be stored here; for both reading and writing on scanner * file frame data. The frame of the scanner file is not the same as a frame from * the camera. *

Definition at line 422 of file ScannerFile.h.

Referenced by AllocateFrameBuffer(), FrameBuffer(), GetNextLine(), MemoryConsumedEstimated(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), ScannerFile(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), and ~ScannerFile().

kkint64 KKLSC::ScannerFile::frameBufferFileOffsetLast

protected

The byte-offset that the last frameBuffer read or written to starts at.

Definition at line 427 of file ScannerFile.h.

Referenced by FrameBufferFileOffsetLast(), InitiateWritting(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), Reset(), ScannerFile(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), and KKLSC::ScannerFile4BitEncoded::WriteBufferFrame().

kkint64 KKLSC::ScannerFile::frameBufferFileOffsetNext

protected

The byte-offset of the next frameBuffer to be read or written

Definition at line 429 of file ScannerFile.h.

Referenced by FrameBufferFileOffsetNext(), FrameRead(), GetNextLine(), InitiateWritting(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), Reset(), ScannerFile(), SkipNextLine(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), and WriteScanLine().

bool KKLSC::ScannerFile::frameBufferLastReadEof

protected

Indicates that the last call to 'ReadBufferFrame' encountered * feof (file) which means the next call to 'ReadBufferFrame' should return eof. *

Definition at line 431 of file ScannerFile.h.

Referenced by GetNextLine(), Reset(), ScannerFile(), and SkipNextLine().

kkuint32 KKLSC::ScannerFile::frameBufferLen

protected

Represents the number of bytes being used in 'frameBuffer'; when data is being * read from a Scanner file you would start reading from this point in the buffer and * while data is be written it will be added to 'frameBuffer' and this variable will * be incremented to reflect the new amount occupied. *

Definition at line 435 of file ScannerFile.h.

Referenced by AllocateFrameBuffer(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), and ScannerFile().

kkuint32 KKLSC::ScannerFile::frameBufferNextLine

protected

Next scan-line in 'frameBuffer' to either read or write; used to compute the * byte offset into the buffer. *

Definition at line 441 of file ScannerFile.h.

Referenced by Close(), FrameRead(), GetNextLine(), KKLSC::ScannerFileSimple::ReadBufferFrame(), KKLSC::ScannerFile2BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile3BitEncoded::ReadBufferFrame(), KKLSC::ScannerFile4BitEncoded::ReadBufferFrame(), ScannerFile(), SkipNextLine(), SkipToScanLine(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), and WriteScanLine().

kkuint32 KKLSC::ScannerFile::frameBufferNumScanLines

protected

The Number of scan-lines that the last call to 'ReadBufferFrame' read.

Definition at line 445 of file ScannerFile.h.

Referenced by FrameRead(), GetNextLine(), ScannerFile(), SkipNextLine(), and SkipToScanLine().

kkuint32 KKLSC::ScannerFile::frameBufferSize

protected

The number of bytes that were allocated to 'frameBuffer'; 'frameBufferLen' * should never exceed this value. *

Definition at line 447 of file ScannerFile.h.

Referenced by AllocateFrameBuffer(), MemoryConsumedEstimated(), ScannerFile(), KKLSC::ScannerFileSimple::SkipToNextFrame(), and KKLSC::ScannerFileSimple::WriteBufferFrame().

kkuint32 KKLSC::ScannerFile::frameHeight

protected

Represents the number of scam lines per frame; as stored in the Scanner File.

Definition at line 398 of file ScannerFile.h.

Referenced by AllocateFrameBuffer(), BuildFrameOffsets(), ExtractHeaderField(), FrameHeight(), FrameRead(), GetNextLine(), InitiateWritting(), RecordRateByTimeIntervals(), ScannerFile(), SkipNextLine(), SkipToScanLine(), and WriteScanLine().

kkuint32 KKLSC::ScannerFile::frameNumCurLoaded

protected

Indicates the frame that is currently loaded in 'frameBuffer'.

Definition at line 451 of file ScannerFile.h.

Referenced by FrameRead(), GetNextLine(), ScannerFile(), SkipNextLine(), SkipToScanLine(), and WriteScanLine().

std::vector<kkint64> KKLSC::ScannerFile::frameOffsets

protected

Will maintain a list of byte offsets; each entry will be the byte offset for * its corresponding frame *

Definition at line 454 of file ScannerFile.h.

bool KKLSC::ScannerFile::frameOffsetsBuildRunning

protected

Definition at line 457 of file ScannerFile.h.

Referenced by BuildFrameOffsets(), BuildFrameOffsetsRunning(), and ScannerFile().

bool KKLSC::ScannerFile::frameOffsetsLoaded

protected

Indicates if the entire scannerFile has been scanned and all entries in * frameOffsets are updated. Can only be set to 'true' upon successful completion * of 'BuildFrameOffsets'. *

Definition at line 459 of file ScannerFile.h.

Referenced by BuildFrameOffsets(), FrameOffsetsLoaded(), and ScannerFile().

GoalKeeperPtr KKLSC::ScannerFile::goalie

protected

Used to control access to the buildFrameIndex table.

Definition at line 464 of file ScannerFile.h.

Referenced by AddStartStopEntryToIndexFile(), BuildFrameOffsets(), CreateGoalie(), DetermineFrameOffsetForFrame(), FrameRead(), GetFrameOffset(), GetNextLine(), ScannerFile(), SkipNextLine(), UpdateFrameOffset(), and ~ScannerFile().

bool KKLSC::ScannerFile::headerDataWritten

protected

Sets to true after all Header data has been written.

Definition at line 399 of file ScannerFile.h.

Referenced by ScannerFile(), and WriteHeader().

ScannerHeaderFieldsPtr KKLSC::ScannerFile::headerFields

protected

Definition at line 400 of file ScannerFile.h.

Referenced by AddHeaderField(), GetValue(), GetValueFloat(), HeaderFields(), MemoryConsumedEstimated(), ReadHeader(), ScannerFile(), and ~ScannerFile().

std::ofstream* KKLSC::ScannerFile::indexFile

protected

When writing a Scanner file will also write out a ByteOffset index file to aid future access to this file.

Definition at line 466 of file ScannerFile.h.

Referenced by AddStartStopEntryToIndexFile(), Close(), LoadIndexFile(), MemoryConsumedEstimated(), and ScannerFile().

KKStr KKLSC::ScannerFile::indexFileName

protected

Definition at line 469 of file ScannerFile.h.

Referenced by AddStartStopEntryToIndexFile(), LoadIndexFile(), Open(), SaveIndexFile(), and ScannerFile().

IOMode KKLSC::ScannerFile::ioMode

protected

Definition at line 401 of file ScannerFile.h.

Referenced by Close(), Open(), and ScannerFile().

kkint32 KKLSC::ScannerFile::largestKnownScanLine

protected

Definition at line 402 of file ScannerFile.h.

Referenced by BuildFrameOffsets(), FrameRead(), GetNextLine(), LargestKnownScanLine(), LoadIndexFile(), ScannerFile(), and SkipNextLine().

kkint32 KKLSC::ScannerFile::lastScanLine

protected

The last scan-line read.

Definition at line 403 of file ScannerFile.h.

Referenced by FrameRead(), GetNextLine(), InitiateWritting(), LastScanLine(), Reset(), ScannerFile(), SkipNextLine(), SkipToScanLine(), and WriteScanLine().

RunLog& KKLSC::ScannerFile::log

protected

Definition at line 404 of file ScannerFile.h.

Referenced by ScannerFile().

kkint32 KKLSC::ScannerFile::nextScanLine

protected

The next scan-line that will be returned by 'GetNextLine'.

Definition at line 405 of file ScannerFile.h.

Referenced by FrameRead(), GetNextLine(), InitiateWritting(), NextScanLine(), Reset(), ScannerFile(), SkipNextLine(), SkipToScanLine(), and WriteScanLine().

bool KKLSC::ScannerFile::opened

protected

Definition at line 406 of file ScannerFile.h.

Referenced by Close(), Open(), Opened(), Reset(), ScannerFile(), and ~ScannerFile().

kkuint32 KKLSC::ScannerFile::pixelsPerScanLine

protected

Definition at line 407 of file ScannerFile.h.

Referenced by AllocateFrameBuffer(), ExtractHeaderField(), GetNextLine(), InitiateWritting(), PixelsPerScanLine(), KKLSC::ScannerFileSimple::ReadBufferFrame(), ScannerFile(), KKLSC::ScannerFile2BitEncoded::SkipToNextFrame(), KKLSC::ScannerFile3BitEncoded::SkipToNextFrame(), KKLSC::ScannerFile4BitEncoded::SkipToNextFrame(), KKLSC::ScannerFileSimple::WriteBufferFrame(), KKLSC::ScannerFile2BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile3BitEncoded::WriteBufferFrame(), KKLSC::ScannerFile4BitEncoded::WriteBufferFrame(), and WriteScanLine().

ScannerFileEntryPtr KKLSC::ScannerFile::scannerFileEntry

protected

Definition at line 471 of file ScannerFile.h.

Referenced by MemoryConsumedEstimated(), and ScannerFile().

float KKLSC::ScannerFile::scanRate

protected

Scan-Lines Per Second.

Definition at line 408 of file ScannerFile.h.

Referenced by ExtractHeaderField(), InitiateWritting(), RecordRateByTimeIntervals(), ScannerFile(), and ScanRate().

StartStopPointList KKLSC::ScannerFile::startStopPoints

protected

Points where he user does or does-not want to process(Count) are tacked in this data structure. Each entry is flagged as a Start or Stop point. These entries are saved in the IndexFile along with the frame offsets table.

Definition at line 474 of file ScannerFile.h.

---

The documentation for this class was generated from the following files:

• C:/Users/Kurt/GitHub/KSquareLibraries/KKLineScanner/ScannerFile.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKLineScanner/ScannerFile.cpp