// FalconHelper.cpp:  Routines for intermediate frame saving from Falcon camera
//
// Copyright (C) 2013 by Boulder Laboratory for 3-Dimensional Electron 
// Microscopy of Cells ("BL3DEMC") and the Regents of the University of
// Colorado.  See Copyright.txt for full notice of copyright and limitations.
//
// Author: David Mastronarde
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include <direct.h>
#include <map>
#include "SerialEM.h"
#include "EMscope.h"
#include "SerialEMDoc.h"
#include "FalconHelper.h"
#include "CameraController.h"
#include "ShiftManager.h"
#include "PluginManager.h"
#include "Utilities\XCorr.h"
#include "Shared\b3dutil.h"
#include "Shared\iimage.h"
#include "Shared\framealign.h"
#include "Shared\CorrectDefects.h"
#include "Shared\SEMCCDDefines.h"

enum {FIF_COMM_ERR = 1, FIF_NO_FILES, FIF_NO_NEW_FILES, FIF_OPEN_OLD, FIF_READ_ERR,
FIF_BAD_SIZE, FIF_MEMORY, FIF_OPEN_NEW, FIF_MISMATCH, FIF_WRITE_ERR, FIF_REMOVE_ERR, 
FIF_NO_MORE_FILES, FIF_BAD_MODE, FIF_CONF_NOT_EXIST, FIF_CONF_OPEN_ERR, 
FIF_CONF_READ_ERR, FIF_CONF_NO_MODE_LINE, FIF_CONF_NOT_INIT, FIF_CONF_BAD_MODE, 
FIF_CONF_WRITE_ERR, FIF_BACKUP_EXISTS, FIF_BACKUP_ERR, FIF_ALIGN_SIZE_ERR, 
FIF_ALIGN_FRAME_ERR, FIF_FINISH_ALIGN_ERR, FIF_DE_READ_ERR, FIF_ERR_PLUGIN_FRAME,
FIF_NO_MORE_FRAMES, RARF_NOT_EXIST, RARF_BUF_TOO_SMALL, RARF_OPEN_ERR, RARF_READ_ERR,
FIF_LAST_CODE};

static const char *errMess[] = {"Unspecified communication error",
"No intermediate frames files found in directory",
"No new intermediate frame files found with name in expected format",
"Error opening intermediate frame file", "Error reading intermediate frame file",
"Cannot find appropriate size information for intermediate frame file",
"Error allocating memory", "Error opening a new MRC file",
"Sizes or modes do not all match between intermediate frame files",
"Error writing image to stack file", //10
"Error removing the intermediate frame file after writing it successfully to stack",
"There are no more files to read", "The frame files have an unrecognized data mode",
"FalconConfig file does not exist or is in unreadable directory",
"FalconConfig file cannot be opened for reading", "Error reading from FalconConfig file",
"Could not recognize the acquisition mode line in the FalconConfig file",
"Falcon configuration file access not set up: if FEI-SEMServer was restarted, SerialEM "
"needs to be restarted", "No recognized acquisition mode in the FalconConfig file",
"Error rewriting the FalconConfig file", //20
"The stack file and its backup already exist",
"Error renaming existing stack file to backup name",
"Frames are not the same size as the image returned to SerialEM and will not be aligned",
"Error aligning a frame in the nextFrame routine",
"Error finishing the frame alignment", "Error reading a frame from the file for alignment"
, "Error getting the next frame from the plugin",
"There are fewer frames available than expected",
"No files found matching specification", "Buffer is too small to return file", // 30
"Error opening file to be returned", "Error reading file to be returned",
};

static void framePrintFunc(const char *strMessage)
{
  CString str = strMessage;
  str.TrimRight('\n');
  str.Replace("\n", "\r\n");
  if (GetDebugOutput('D') || GetDebugOutput('E'))
    PrintfToLog("Framealign : %s", (LPCTSTR)str);
}

CFalconHelper::CFalconHelper(void)
{
  SEMBuildTime(__DATE__, __TIME__);
  mWinApp = (CSerialEMApp *)AfxGetApp();
  mNumStartLines = -1;
  mConfigBackedUp = false;
  mLastSavedDummy = false;
  mFalconGainRef = NULL;
  mRotData = NULL;
  mStoreMRC = NULL;
  mImage = NULL;
  mImage2 = NULL;
  mFrameAli = NULL;
  mWaitInterval = 70;
  mWaitMaxCount = 10;
  mStackingFrames = false;
  mRotFlipForComFile = 0;
  mUseGpuForAlign[0] = mUseGpuForAlign[1] = 0;
  mGpuForContinuousAli = 0;
  mContinuousAliParam.aliBinning = 4;
  mContinuousAliParam.numAllVsAll = 0;
  mContinuousAliParam.rad2Filt1 = 0.06f;
  mLastEERcountScaling = 100.f;
  mLastUseOfFalconRef = 0;
  mReadEERantialiased = true;
}

CFalconHelper::~CFalconHelper(void)
{
  delete mFrameAli;
  delete mFalconGainRef;
}

void CFalconHelper::InitializePointers(void)
{
  mCamera = mWinApp->mCamera;
}

// Read the configuration file and save its essential features
// This is now used for Falcon (skipConfigs 0 or 1) or  for setting up frame alignment 
// for DE (-1) or plugin cameras (-2) or continuous mode images (-3).  
// This is safe to call multiple times with skipConfig != 0
void CFalconHelper::Initialize(int skipConfigs)
{
  CString configFile, str, dir, fname;
  int error = 0, skipInd = -1 - skipConfigs;
  int saveNumAVA = mContinuousAliParam.numAllVsAll;
  const char *skipType[] = {"DE", "Plugin", "continuous mode"};
  long version;
  B3DCLAMP(skipInd, 0, 2);
  mPlugFuncs = mWinApp->mScope->GetPlugFuncs();
  if (!mPlugFuncs && skipConfigs >= 0)
    return;
  if (skipConfigs == -3) {
    mCamera->SetFrameAliDefaults(mContinuousAliParam, "Continuous mode set", 
      mContinuousAliParam.aliBinning, mContinuousAliParam.rad2Filt1, 0);
    mContinuousAliParam.binToTarget = 0;
    mContinuousAliParam.numAllVsAll = saveNumAVA;
  }
  mReadoutInterval = mCamera->GetFalconReadoutInterval();
  if (!mFrameAli) {
    mFrameAli = new FrameAlign();
    mFrameAli->setPrintFunc(framePrintFunc);
    if (skipConfigs == -3 && !mGpuForContinuousAli)
      return;
    if (!mFrameAli->gpuAvailable(0, &mGpuMemory,
      (GetDebugOutput('E') || GetDebugOutput('D') || GetDebugOutput('T') ||
        GetDebugOutput('M')) ? 1 : 0)) {
      mGpuMemory = 0;
      mGpuForContinuousAli = 0;
    }
    SEMTrace('1', "GPU %s available for %s aligning", mGpuMemory ? "IS" : "IS NOT",
      skipConfigs >= 0 ? "Falcon" : skipType[skipInd]);
  }
  configFile = mCamera->GetFalconFrameConfig();
  if (configFile.IsEmpty() || skipConfigs != 0)
    return;
  error = mPlugFuncs->FIFinitialize((LPCTSTR)configFile, mReadoutInterval);
  if (error) {
    mWinApp->AppendToLog("Error opening or reading from intermediate frame file " +
      configFile);
    mCamera->SetMaxFalconFrames(0);
  }
  if (mWinApp->mScope->GetPluginVersion() < FEI_PLUGIN_MANAGE_FAL_CONF) {
    mCamera->SetCanUseFalconConfig(-1);
    return;
  }

  // If supported, try to get a name for FalconConfig file and initialize its use
  str = mCamera->GetFalconConfigFile();
  if (str.IsEmpty()) {
    UtilSplitPath(configFile, dir, fname);
    str = dir + "\\FalconConfig.xml";
  }
  error = mPlugFuncs->FIFinitFalconConfig((LPCTSTR)str, &version);
  if (error) {
    mWinApp->AppendToLog("Error initializing access to Falcon configuration file:\r\n" +
      str + "\r\n" + GetErrorString(error));
    mCamera->SetCanUseFalconConfig(-1);
  } else if (mCamera->GetCanUseFalconConfig() < 0) {
    mCamera->SetCanUseFalconConfig(version);
  }
}

// Check the frame saving state in FalconConfig and optionally set it
// Output error message if message is non-NULL
int CFalconHelper::CheckFalconConfig(int setState, int &state, const char *message)
{
  long lstate;
  int error = mPlugFuncs->FIFcheckFalconConfig(setState, &lstate);
  if (error && message)
    SEMMessageBox(GetErrorString(error) + CString("\n\n") + message);
  state = lstate;
  if (!error)
    mCamera->SetFrameSavingEnabled(state > 0);
  return error;
}

// Call the plugin/server to modify the configuration file to save the desired frames, or 
// put out a dummy file if no frame-saving is selected, or just save the list of readouts
// for advanced interface.  Also set up frame alignment
int CFalconHelper::SetupConfigFile(ControlSet &conSet, int consNum, CString localPath,
  CString &directory, CString &filename, CString &configFile, BOOL stackingDeferred, 
  CameraParameters *camParams, long &numFrames)
{
  CFileStatus status;
  CString str;
  long temp = 1;
  long *readPtr = &temp;
  float frameInterval = mCamera->GetFalconReadoutInterval();
  int ind, block, numInFracs, numRawFrames = 0;
  bool saveFrames = conSet.saveFrames || (conSet.alignFrames && conSet.useFrameAlign);
  bool eerMode = mCamera->IsSaveInEERMode(camParams, &conSet);
  mDoingAdvancedFrames = FCAM_ADVANCED(camParams) != 0;
  if (!mDoingAdvancedFrames) {

    // Check the directory entry and assign local path if needed
    if (saveFrames && directory.IsEmpty()) {
      SEMMessageBox("You must specify a directory for saving the frame images");
      return 1;
    }
    if (localPath.IsEmpty())
      localPath = directory;

    // Create directory if it doesn't exist
    if (saveFrames && !CFile::GetStatus((LPCTSTR)directory, status)) {
      SEMTrace('E', "Directory %s does not exist, creating it", (LPCTSTR)directory);
      if (_mkdir((LPCTSTR)directory)) {
        str.Format("An error occurred creating the directory:\n%s\n"
          "for saving frame images.  Does its parent directory exist?", 
          (LPCTSTR)directory);
        SEMMessageBox(str);
        return 1;
      }
    }
  }

  // Get number of raw frames, constrained to the sum size, and for MRC saving, 
  // check that the summed frame list is consistent and fix it if not
  if (camParams->FEItype == FALCON4_TYPE) {
    ind = mCamera->GetFalconRawSumSize(camParams);
    numRawFrames = ind * B3DNINT(conSet.exposure /
      (mCamera->GetFalconReadoutInterval(camParams) * ind));
    if (!eerMode && numRawFrames > 0) {
      GetFrameTotals(conSet.summedFrameList, numInFracs);
      if (numInFracs != numRawFrames / ind)
        AdjustSumsForExposure(camParams, &conSet, conSet.exposure, consNum);
    }
  }

  // Build the list of readouts
  mReadouts.clear();
  if (eerMode || FCAM_CONTIN_SAVE(camParams)) {
    mReadouts.push_back(1);
  } else {
    mReadouts.clear();
    for (block = 0; block < (int)conSet.summedFrameList.size() / 2; block++)
      for (ind = 0; ind < conSet.summedFrameList[block * 2]; ind++)
        mReadouts.push_back((long)conSet.summedFrameList[block * 2 + 1]);
  }
  numFrames = (int)mReadouts.size();
  if (numFrames > 0) {
    temp = numFrames;
    readPtr = &mReadouts[0];
  }
  
  // For EER, replace numFrames and send it as the ending frame # so plugin can adjust
  // exposure
  if (eerMode) {
    numFrames = numRawFrames;
    mReadouts[0] = numFrames;
  }
  if (mDoingAdvancedFrames) {
    ind = -1;
    //if (camParams->FEItype == FALCON2_TYPE)
      //ind = stackingDeferred ? 1 : 0;
    if (mPlugFuncs->ASIsetupFrames(camParams->eagleIndex, ind, temp, conSet.numSkipBefore,
      readPtr, (LPCTSTR)directory, (LPCTSTR)filename, 0, 0.)) {
      str.Format("Error setting up for frame saving from %s:\n%s", 
        FCAM_CONTIN_SAVE(camParams) ? "Ceta" : "Falcon",mPlugFuncs->GetLastErrorString());
      SEMMessageBox(str);
      return 1;
    }

  } else {
    if (mPlugFuncs->FIFsetupConfigFile((LPCTSTR)localPath, stackingDeferred, 
      saveFrames, temp, conSet.numSkipBefore, readPtr)) {
        str.Format("Error opening or writing to intermediate frame configuration file"
          " %s:\n%s", (LPCTSTR)configFile, mPlugFuncs->GetLastErrorString());
        SEMMessageBox(str);
        return 1;
    }
  }

  // Save frame alignment information and set up aligning if doing here
  mUseFrameAlign = 0;
  mJustAlignNotSave = !conSet.saveFrames && conSet.alignFrames && 
    conSet.useFrameAlign == 1;
  if (conSet.alignFrames && conSet.useFrameAlign == 1) {
    temp = eerMode ? B3DNINT(conSet.exposure / conSet.frameTime) : numFrames;
    mUseFrameAlign = conSet.useFrameAlign;
    mFAparamSetInd = conSet.faParamSetInd;
    ind = SetupFrameAlignment(conSet, camParams, mGpuMemory, mUseGpuForAlign, temp);
    return ind;
  }
  return 0;
}

// Take care of finding, copying, and reading in the Falcon 4 EER gain reference
int CFalconHelper::ManageFalconReference(bool saving, bool aligning, 
  CString localFrameFolder)
{
  CString str, refName, refDir, mess;
  CFileStatus status;
  ImodImageFile *iiFile;
  int keepRefLimit = 10;
  int checkRefInterval = 5;
  int now = mWinApp->MinuteTimeStamp();
  int err, superFac;
  size_t newSize;
  bool needCopy = false;
  char messBuf[256];
  refDir = mCamera->GetFalconReferenceDir();
  if (refDir.IsEmpty())
    return 0;

  // For the periodic call to free unused reference
  if (!saving && !aligning) {
    if (mFalconGainRef && now - mLastUseOfFalconRef > keepRefLimit)
      B3DDELETE(mFalconGainRef);
    return 0;
  }

  // Check the reference if enough time has passed
  if (now - mLastFalconRefCheck >= checkRefInterval || mFalconRefName.IsEmpty()) {

    // Find the reference
    refName = FindEERGainReference();
    if (refName.IsEmpty()) {
      str.Format("Could not find Falcon gain reference in %s", (LPCTSTR)refDir);
      mFalconRefName = "";
      SEMMessageBox(str);
      return 1;
    }

    // If it does not match set up for copy
    if (refName != mFalconRefName) {
      mFalconRefName = refName;
      needCopy = true;
    }
    mLastFalconRefCheck = now;
  }

  refName = refDir + "\\" + mFalconRefName;

  // Folder is passed if a copy is needed
  if (!localFrameFolder.IsEmpty()) {

    // if don't need a copy, check if it is OK in the current frame dir
    if (!needCopy)
      needCopy = localFrameFolder != mLastRefSavedInDir;

    str = localFrameFolder + "\\" + mFalconRefName;
    if (!needCopy)
      needCopy = !CFile::GetStatus((LPCTSTR)str, status);

    // Make the copy if necessary
    if (needCopy) {
      err = 0;
      if (!CFile::GetStatus((LPCTSTR)localFrameFolder, status)) {
        if (UtilRecursiveMakeDir(localFrameFolder, mess)) {
          str.Format("Failed to copy gain reference from %s to %s: %s",
            (LPCTSTR)refDir, (LPCTSTR)localFrameFolder, (LPCTSTR)mess);
          SEMMessageBox(str);
          err = 1;
        }
      }
      if (!err && !CopyFile((LPCTSTR)refName, (LPCTSTR)str, false)) {
        mess.Format("Failed to copy gain reference from %s to %s  (error %d)",
          (LPCTSTR)refDir, (LPCTSTR)localFrameFolder, GetLastError());
        SEMMessageBox(mess);
      }

      mLastRefSavedInDir = localFrameFolder;
    }
  }

  // Done if names match last reference and reference exists at the right super-resolution
  // or if not aligning
  if ((mLastGainRefRead == mFalconRefName && mEERsuperRes == mGainRefSuperRes &&
    mFalconGainRef) || !aligning)
    return 0;

  // Open file
  superFac = GetEERsuperFactor(mEERsuperRes);
  iiFile = iiOpen((LPCTSTR)refName, "rb");
  if (!iiFile) {
    SEMMessageBox("Error opening EER gain reference: " + refName + "\r\n   (" +
    CString(b3dGetError()) + ")");
    return 1;
  }

  // Get the defects
  err = 0;
  mFoundFalconDefects = false;
  if ((iiFile->file != IIFILE_TIFF) || iiFile->mode != MRC_MODE_FLOAT) {
    str.Format("The EER gain reference is not a floating point TIFF file: " + refName);
    err = 1;
  } else {

    // Set defect pad for antialias reading; was 1 for bin reading
    err = CorDefProcessFeiDefects(iiFile, mFalconDefects, iiFile->nx, iiFile->ny, false,
      superFac, mReadEERantialiased ? 20 : 1, NULL, messBuf, 256);
    if (err > 0)
      str.Format("Error processing camera defects from EER gain reference file:\n%s",
        messBuf);
    else if (err < 0)
      err = 0;
    else
      mFoundFalconDefects = true;
  }

  // Check that buffer is big enough
  newSize = (size_t)(superFac * superFac * iiFile->nx) * iiFile->ny;
  if (!err && (!mFalconGainRef || newSize > (size_t)mGainSizeX * mGainSizeY)) {
    delete[] mFalconGainRef;
    NewArray(mFalconGainRef, float, newSize);
    if (!mFalconGainRef) {
      str = "Error allocating array for EER gain reference";
      err = 1;
    }
  }

  // Read it and expand it, save the info for aligning
  if (!err) {
    err = iiReadSection(iiFile, (char *)mFalconGainRef, 0);
    if (!err) {
      if (mEERsuperRes)
        CorDefExpandGainReference(mFalconGainRef, iiFile->nx, iiFile->ny, superFac,
          mFalconGainRef);
      mGainSizeX = iiFile->nx * superFac;
      mGainSizeY = iiFile->ny * superFac;
      mGainRefSuperRes = mEERsuperRes;
      mLastGainRefRead = mFalconRefName;
    } else {
      str.Format("Error reading gain reference from TIFF file; %s", b3dGetError());
    }
  }

  // Close, clean up on error
  iiDelete(iiFile);
  if (err) {
    SEMMessageBox(str);
    B3DDELETE(mFalconGainRef);
  }
  return err;
}

// Find the newest EER gain reference in the reference folder.
CString CFalconHelper::FindEERGainReference()
{
  WIN32_FIND_DATA FindFileData;
  HANDLE hFind = NULL;
  double curRefTime, bestRefTime = 0.;
  CString refDir = mCamera->GetFalconReferenceDir();
  CString tmp, str = refDir + "\\*EER_GainReference*";

  hFind = FindFirstFile((LPCTSTR)str, &FindFileData);
  if (hFind == INVALID_HANDLE_VALUE)
    return "";

  do {
    tmp = FindFileData.cFileName;
    if (tmp.Right(4) != ".tif" && tmp.Right(5) != ".gain" && tmp.Right(5) != ".tiff")
      continue;
    curRefTime = B3DMAX(429.4967296 * FindFileData.ftCreationTime.dwHighDateTime +
      1.e-7 * FindFileData.ftCreationTime.dwLowDateTime,
      429.4967296 * FindFileData.ftLastWriteTime.dwHighDateTime +
      1.e-7 * FindFileData.ftLastWriteTime.dwLowDateTime);
    if (curRefTime > bestRefTime) {
      bestRefTime = curRefTime;
      str = FindFileData.cFileName;
    }
  } while (FindNextFile(hFind, &FindFileData) != 0);

  FindClose(hFind);
  return str;
}

// Set up for frame alignment given the control set, camera parameters, gpu flags, and
// expected number of frames
int CFalconHelper::SetupFrameAlignment(ControlSet &conSet, CameraParameters *camParams, 
  float gpuMemory, int *useGPU, int numFrames)
{
  CString str;
  int nx, ny, superFac, numFilters = 0, ind, deferGpuSum = 0;
  float radius2[4], sigma2[4], sigma1 = 0.03f; 
  float fullTaperFrac = 0.02f;
  float trimFrac = fullTaperFrac;
  float taperFrac = 0.1f;
  float kFactor = 4.5f;
  float maxMaxWeight = 0.1f;
  float totAliMem = 0.,cpuMemFrac = 0.75f;
  float maxMemory, memoryLimit;
  int xTrim, yTrim, left, right, top, bottom, sizeX, sizeY;
  int numAliFrames, numAllVsAll, groupSize, refineIter, doSpline, gpuFlags = 0;
  FrameAliParams param;
  CArray<FrameAliParams, FrameAliParams> *faParams = 
    mCamera->GetFrameAliParams();
  if (mFAparamSetInd < 0) {
    param = mContinuousAliParam;
  } else {
    if (conSet.faParamSetInd < 0 || conSet.faParamSetInd >= faParams->GetSize()) {
      str.Format("The index of the parameter set chosen for frame alignment, %d, is out "
        "of range", conSet.faParamSetInd);
      SEMMessageBox(str);
      return 1;
    }

    if (conSet.useFrameAlign > 1)
      return 0;

    param = faParams->GetAt(conSet.faParamSetInd);
  }

  // get size of images, and subset limits if any
  mDarkp = NULL;
  mGainp = NULL;
  param.multAliBinByEERfac = false;
  mAlignTruncation = 0.;
  if (camParams->FEItype) {
    if (mEERsumming > 0) {
      superFac = GetEERsuperFactor(mEERsuperRes);
      nx = camParams->sizeX * superFac;
      ny = camParams->sizeY * superFac;
      mSumBinning = conSet.binning * superFac;
      param.aliBinning *= superFac;
      if (param.truncate)
        mAlignTruncation = param.truncLimit;

      // May have to trim the full-sized EER sum
      mTrimXstart = conSet.left / conSet.binning;
      mTrimXend = conSet.right / conSet.binning - 1;
      mTrimYstart = conSet.top / conSet.binning;
      mTrimYend = conSet.bottom / conSet.binning - 1;
      mTrimDEsum = (conSet.left > 0 || conSet.right < camParams->sizeX ||
        conSet.top > 0 || conSet.bottom < camParams->sizeY);
      param.multAliBinByEERfac = !mReadEERantialiased;
      mLastUseOfFalconRef = mWinApp->MinuteTimeStamp();

    } else {
      nx = (conSet.right - conSet.left) / conSet.binning;
      ny = (conSet.bottom - conSet.top) / conSet.binning;
      mSumBinning = 1;
      mTrimDEsum = false;
    }
    mDEframeNeedsTrim = false;
  } else if (mProcessingPlugin || mFAparamSetInd < 0) {
    nx = mHeadNums[0];
    ny = mHeadNums[1];
    mSumBinning = 1;
    mTrimDEsum = false;
    mDEframeNeedsTrim = false;
  } else {

    // DE camera: the size is already known and is the image size
    // Binning must be multiplied by 2 for super-res or divided by 2 for HW bin
    // The binning of image being read is binDivisor / 2 (0.5 for SR, 2 for HW, etc)
    nx = mNx;
    ny = mNy;
    mSumBinning = (conSet.binning * 2) / SuperResHardwareBinDivisor(camParams, &conSet);

    // Raise trim fraction if usable area indicates bigger border needed
    // But have to get usable area back to the chip coordinates
    left = camParams->defects.usableLeft;
    top = camParams->defects.usableTop;
    sizeX = camParams->sizeX;
    sizeY = camParams->sizeY;
    right = sizeX;
    bottom = sizeY;
    if (camParams->defects.usableRight > 0)
      right = camParams->defects.usableRight;
    if (camParams->defects.usableBottom > 0)
      bottom = camParams->defects.usableBottom;
    xTrim = right - left;
    yTrim = bottom - top;
    CorDefUserToRotFlipCCD(mAliSumRotFlip, 1, sizeX, sizeY, xTrim, yTrim, top, left, 
      bottom, right);
    
    xTrim = B3DMAX(left, sizeX - right);
    yTrim = B3DMAX(top, sizeY - bottom);
    ACCUM_MAX(trimFrac, (float)xTrim / (float)sizeX);
    ACCUM_MAX(trimFrac, (float)yTrim / (float)sizeY);
  }
  mAlignSubset = false;
  numAliFrames = numFrames;
  if (param.alignSubset && conSet.saveFrames) {
    mAlignStart = B3DMAX(1, param.subsetStart);
    mAlignEnd = B3DMIN(numFrames, param.subsetEnd);
    if (mAlignEnd - mAlignStart > 0) {
      numAliFrames = mAlignEnd + 1 - mAlignStart;
      mAlignSubset = true;
    }
  }

  // Get some other parameters
  numAllVsAll = mCamera->NumAllVsAllFromFAparam(param, numAliFrames, groupSize, 
    refineIter, doSpline, numFilters, radius2);
  for (ind = 0; ind < numFilters; ind++)
    sigma2[ind] = (float)(0.001 * B3DNINT(1000. * param.sigmaRatio * radius2[ind]));

  // Set a memory limit
  memoryLimit = (float)mWinApp->GetMemoryLimit();
  if (!memoryLimit) {
    memoryLimit = (float)b3dPhysicalMemory();
#ifndef _WIN64
    memoryLimit = B3DMIN(memoryLimit, 3.e9f);
#endif
    memoryLimit *= cpuMemFrac;
  }
  maxMemory = memoryLimit - (float)mWinApp->mBufferWindow.MemorySummary();

  // Evaluate all memory needs. PROBLEM: binned data and alignment binning
  totAliMem = UtilEvaluateGpuCapability(nx, ny, sizeof(short int), false, false,
    mSumBinning, param, numAllVsAll, numAliFrames, refineIter, groupSize, numFilters, 
    doSpline, useGPU[0] ? mGpuMemory : 0., maxMemory, gpuFlags, deferGpuSum, mGettingFRC);
  if (totAliMem > maxMemory)
    PrintfToLog("WARNING: With current parameters, memory needed for aligning "
    "(%.1f GB) exceeds allowed\r\n  memory usage (%.1f GB), controlled by MemoryLimit"
    " property if it is set", totAliMem, maxMemory);
  ind = mFrameAli->initialize(mSumBinning, UtilGetFrameAlignBinning(param, nx, ny), 
    trimFrac, numAllVsAll, refineIter, 
    param.hybridShifts, (deferGpuSum | doSpline) ? 1 : 0, groupSize, nx, ny, 
    fullTaperFrac, taperFrac, param.antialiasType, 0., radius2, sigma1, sigma2, 
    numFilters, param.shiftLimit, kFactor, maxMaxWeight, 0, numFrames, 0, gpuFlags, 
    (GetDebugOutput('E') || GetDebugOutput('D') || GetDebugOutput('T')) ? 11 : 0);
  if (ind) {
    str.Format("The framealign routine failed to initialize (error %d)", ind);
    mFrameAli->cleanup();
    SEMMessageBox(str);
    return 1;
  }
  SEMTrace('E', "Frame alignment initialized");
  return 0;
}


// Stack the frames, possibly located in localPath, into a file with the given root name
// the given directory, with potential division by a factor, rotation, and flip
// For advanced interface, this is called for aligning only, and localPath should be the 
// full path to the input stack file
int CFalconHelper::StackFrames(CString localPath, CString &directory, CString &rootname, 
  long divideBy2, int divideBy, float floatScale, int rotateFlip, int aliSumRotFlip, 
  float pixel, BOOL doAsync, bool readLocally, int aliParamInd, long &numStacked, 
  CameraThreadData *camTD)
{
  int invBeforeMap[8] = {6, 7, 4, 5, 2, 3, 0, 1};
  int ind, eerFlags, totalSubframes = 0, start, end, retval = 0;
  char errStr[160];
  CFileStatus status;
  CString str, str2;
  CFile file;
  mDeletePrev = false;
  mProcessingPlugin = false;
  mNeedNormHere = false;
  if (localPath.IsEmpty())
    localPath = directory;

  // Copy arguments to members and set up to do one call per frame
  mLocalPath = localPath;
  mDirectory = directory;
  mRootname = rootname;
  mDivideBy = divideBy;
  mDivideBy2 = divideBy2;
  mFloatScale = floatScale;
  mRotateFlip = rotateFlip;

  // Falcon 4 saves MRC reoriented, but rotation/flip is needed for EER
  if (camTD->FEItype == FALCON4_TYPE && !mEERsumming)
    aliSumRotFlip = 0;
  mRotFlipForComFile = aliSumRotFlip;
  if (camTD->FEItype == FALCON4_TYPE && mEERsumming) {
    B3DCLAMP(aliSumRotFlip, 0, 7);
    aliSumRotFlip = invBeforeMap[aliSumRotFlip];
  }
  mAliSumRotFlip = aliSumRotFlip;
  mSumNeedsRotFlip = mAliSumRotFlip != 0;
  mPixel = pixel;
  mReadLocally = readLocally;
  mCamTD = camTD;
  mAliComParamInd  = aliParamInd;

  // Falcon 4 at least saves MRC with metadata so this applies when there is
  // no metadata to indicate origin and inversion of file.  It is not known if Falcon 3
  // now does this too, in which case this will be a wrong operation, hence an override
  if ((camTD->CamFlags & PLUGFEI_USES_ADVANCED) && camTD->FEItype != FALCON4_TYPE) {
    B3DCLAMP(mRotFlipForComFile, 0, 7);
    mRotFlipForComFile = invBeforeMap[mRotFlipForComFile];
    if (camTD->FEItype == FALCON3_TYPE && mCamera->GetRotFlipInFalcon3ComFile() >= 0)
      mRotFlipForComFile = mCamera->GetRotFlipInFalcon3ComFile();
  }

  // For linear Falcon 3, the frames are all averaged, so we need to switch to floatScale
  // if necessary and adjust it for average # of subframes in each frame
  if (IS_FALCON3_OR_4(camTD) && !camTD->GatanReadMode) {
    start = 0;
    end = (int)mReadouts.size();
    if (mAlignSubset) {
      start = mAlignStart - 1;
      end = B3DMIN(mAlignEnd, end);
      if (start >= end)
        start = 0;
    }
    for (ind = start; ind < end; ind++)
      totalSubframes += mReadouts[ind];
    if (!mFloatScale)
      mFloatScale = (float)( 1. / pow(2., mDivideBy));
    mFloatScale = (float)((mFloatScale * totalSubframes) / (end - start));
  }

  // EER, do not touch the passed # stacked parameter
  if (!mEERsumming)
    numStacked = 0;
  mNumStacked = 0;
  mNumAligned = 0;
  mAlignError = 0;
  mNx = -1;
  mNy = -1;
  mDeleteList.clear();
  mStartedAsyncSave = -1;
  str = mDirectory + "\\" + mRootname + (mEERsumming ? ".eer" : ".mrc");
  SEMTrace('E', "In stackFrames  local %d %s", readLocally ? 1 : 0, (LPCTSTR)localPath);

    // Open a file locally if flag set for that
  if (readLocally) {
    if (mEERsumming > 0) {
      mFloatScale = mLastEERcountScaling * pow((float)GetEERsuperFactor(mEERsuperRes), 2);
      eerFlags = mWinApp->mScope->GetSimulationMode() ? IIFLAG_IGNORE_BAD_EER_END : 0;
      if (mEERsuperRes < 2 && mReadEERantialiased) {
        eerFlags |= (IIFLAG_ANTIALIAS_EER | IIFLAG_EER_USE_LANCZOS);
        mFloatScale /= 100.;
      }
      tiffSetEERreadProperties(mEERsuperRes, mEERsumming, eerFlags);
    }
    mFrameFP = iiFOpen((LPCTSTR)localPath, "rb");
    if (!mFrameFP) {
      _get_errno(&ind);
      strerror_s(errStr, 160, ind);
      SEMTrace('E', "Error opening frame stack at local path: %s\r\n    %s", 
        (LPCTSTR)localPath, errStr);
      return FIF_OPEN_OLD;
    }
    if (mrc_head_read(mFrameFP, &mMrcHeader)) {
      SEMTrace('E', "Error reading frame stack header: %s", b3dGetError());
      iiFClose(mFrameFP);
      return FIF_OPEN_OLD;
    }
    mNumFiles = mMrcHeader.nz;
    mHeadNums[0] = mMrcHeader.nx;
    mHeadNums[1] = mMrcHeader.ny;

    // This builds in the assumption that the FEI file IS inverted AND that we want 
    // inverted images in here anyway, in case it is eventually recognized as inverted
    mMrcHeader.yInverted = 0;
  } else {

    // Get the file map or open the file
    retval = mPlugFuncs->FIFbuildFileMap((LPCTSTR)localPath, &mNumFiles, &mHeadNums[0],
      &mHeadNums[1]);
    if (retval)
      return retval;
  }

  if ((ind = MakeBackupIfFileExists(str)) != 0)
    return ind;

  // Save the last directory a frame file was in
  if (!mJustAlignNotSave)
    UtilSplitPath(mDoingAdvancedFrames ? localPath : str, mLastFrameDir, str2);

  // Start asynchronous looping on files
  mFileInd = 0;
  if (doAsync) {
    for (ind = 0; ind < mNumFiles; ind++)
      mDeleteList.push_back(0);
    mWaitStart = GetTickCount();
    mWaitCount = 0;
    mStackingFrames = true;
    mWinApp->AddIdleTask(TASK_STACK_FALCON, 1, 0);
    if (!mEERsumming)
      numStacked = mNumFiles;
    return 0;
  }

  // Loop on images; stop on fatal errors or on no more files
  while (mFileInd < mNumFiles) {
    StackNextTask(0);
    if (!mNumStacked && !mNumAligned && 
      (mStackError == FIF_MEMORY || mStackError == FIF_OPEN_NEW)) {
        retval = mStackError;
        break;
    }
    if (mStackError == FIF_NO_MORE_FILES)
      break;
  }
  if (!mEERsumming)
    numStacked = mNumStacked;
  CleanupAndFinishAlign(!mJustAlignNotSave && !mDoingAdvancedFrames, 0);
  return retval;
}

// Check if file exists and if there is already a backup file
int CFalconHelper::MakeBackupIfFileExists(CString &str)
{
  CFileStatus status;
  if (!mJustAlignNotSave && !mDoingAdvancedFrames) {
    if (CFile::GetStatus((LPCTSTR)str, status)) {
      if (CFile::GetStatus((LPCTSTR)(str + "~"), status))
        return FIF_BACKUP_EXISTS;
      if (imodBackupFile((LPCTSTR)str))
        return FIF_BACKUP_ERR;
      PrintfToLog("Stack file %s already exists; making it a backup by adding ~",
        (LPCTSTR)str);
    }
  }
  return 0;
}

// Stack or align the next frame or finish up if none: param is > 0 for asynchronous stacking
void CFalconHelper::StackNextTask(int param)
{
  int ind, val;
  short *outPtr, *outData;
  char title[80];
  CString str;
  FileOptions fileOpt;
  CameraParameters *camParam = mWinApp->GetActiveCamParam();
  CameraDefects *useDefects = NULL;
  int useNxGain = mNx, useNyGain = mNy;
  float *useGainArr = NULL;
  bool saving = !mJustAlignNotSave && !mDoingAdvancedFrames;
  bool hasDefects;
  long amtErr;
  int rotateForSave = saving ? mRotateFlip : 0;
  int skipAlign = 0;
  mStackError = 0;

  // Set variable if aligning subset and before or after it
  if (mUseFrameAlign && mAlignSubset && mFileInd < mAlignStart - 1)
    skipAlign = -1;
  if (mUseFrameAlign && mAlignSubset && mFileInd > mAlignEnd - 1)
    skipAlign = 1;
  
  // Termination conditions if running asynchronously, including a possible external stop:
  // out of files, past the subset for advanced frames, or aligning and stopped
  if (param && (mFileInd >= mNumFiles || (mDoingAdvancedFrames && skipAlign > 0) ||
    (mUseFrameAlign && !mCamera->GetStartedFalconAlign()))) {
    CleanupAndFinishAlign(saving, param);
    return;
  }

  if (!mStackError && mNx < 0) {

    // Set size, get array for reading and new KImage
    mNx = mHeadNums[0];
    mNy = mHeadNums[1];
    if (rotateForSave)
      NewArray2(mRotData, short, mNx, mNy);
    if (mEERsumming > 0) {
      if (mReadEERantialiased)
        mImage = new KImageShort(mNx, mNy);
      else
        mImage = (KImageShort *)(new KImage(mNx, mNy));
    } else {
      mImage = new KImageShort((rotateForSave % 2) ? mNy : mNx,
        (rotateForSave % 2) ? mNx : mNy);

      // It seems that advance interface returns signed only
      if (!mDivideBy2 && !mDoingAdvancedFrames)
        mImage->setType(kUSHORT);
    }
    mUseImage2 = 0;
    if (mUseFrameAlign && !mEERsumming && 
      (mCamTD->DMSizeX != ((mAliSumRotFlip % 2) ? mNy : mNx) || 
      mCamTD->DMSizeY != ((mAliSumRotFlip % 2) ? mNx : mNy))) {
        mAlignError = FIF_ALIGN_SIZE_ERR;
        mFrameAli->cleanup();
        if (!saving) {
          CleanupAndFinishAlign(saving, param);
          return;
        }
    }

    // Here is the test for whether to save asynchronously also, hereafter mImage2 is
    // the non-NULL when doing so.  If this is bad locally, could change to 
    // mUsePlugin && mPlugFuncs->FIFcleanUp2 && CBaseSocket::ServerIsRemote(FEI_SOCK_ID)
    if (saving && param && mWinApp->mBufferManager->GetSaveAsynchronously()) {
      if (mEERsumming > 0) {
        mImage2 = (KImageShort *)(new KImage(mNx, mNy));
      } else {
        mImage2 = new KImageShort((mRotateFlip % 2) ? mNy : mNx,
          (mRotateFlip % 2) ? mNx : mNy);
        if (!mDivideBy2)
          mImage2->setType(kUSHORT);
      }
      mUseImage2 = -1;
    }
    if (!mImage->getData() || (mImage2 && !mImage2->getData()) || 
      (rotateForSave && !mRotData)) {
        mStackError = FIF_MEMORY;

    } else if (saving) {

      // Set up file options and get storage
      fileOpt.maxSec = 1;
      fileOpt.mode = mDivideBy2 ? MRC_MODE_SHORT : MRC_MODE_USHORT;
      fileOpt.typext = 0;
      fileOpt.useMdoc = false;
      fileOpt.leaveExistingMdoc = true;
      fileOpt.montageInMdoc = false;
      fileOpt.fileType = STORE_TYPE_MRC;
      mStoreMRC = new KStoreMRC(mDirectory + "\\" + mRootname + ".mrc", fileOpt);
      if (mStoreMRC == NULL || !mStoreMRC->FileOK()) {
        mStackError = FIF_OPEN_NEW;
      } else {
        mWinApp->mDocWnd->MakeSerialEMTitle(CString(mProcessingPlugin ? 
          "Frame images" : "Falcon intermediate images"), title);
        mStoreMRC->AddTitle(title);
        mStoreMRC->SetPixelSpacing(mPixel);
      }
    }
    if (mStackError) {
      CleanupStacking();
      if (param)
        PrintfToLog("Error %d occurred trying to stack frames: %s", mStackError, 
        errMess[mStackError - 1]);
      return;
    }

  }
  outData = (short *)(mUseImage2 > 0 ? mImage2->getData() : mImage->getData());
  outPtr = rotateForSave ? mRotData : outData;

  // Read the data locally or from plugin
  // Can skip frames not being aligned if just reading directly if doing advanced and
  // past the end
  if (!mStackError) {
    if (mProcessingPlugin) {
      if (camParam->AMTtype) {
        try {
          mCamTD->amtCam->GetNextFrame(outPtr, mNx * mNy, &amtErr);
          ind = amtErr;
        }
        catch (_com_error E) {
          ind = 1;
        }

      } else {
        ind = mCamTD->plugFuncs->GetNextFrame(outPtr, mNx * mNy);
      }
      if (ind)
        mStackError = ind < 0 ? FIF_NO_MORE_FRAMES : FIF_ERR_PLUGIN_FRAME;
    } else if (mReadLocally) {
      if (!skipAlign && mrc_read_slice(outPtr, mFrameFP, &mMrcHeader, mFileInd, 'Z'))
        mStackError = FIF_READ_ERR;
    } else if (!(mDoingAdvancedFrames && skipAlign > 0)) {
      mStackError = mPlugFuncs->FIFgetNextFrame(outPtr, mDivideBy2, mDivideBy, 
        mDeletePrev);
    }
    mDeletePrev = false;
  }

  if (mProcessingPlugin && mNeedNormHere)
    mCamera->ProcessImageOrFrame(outPtr, mImage->getType(), mProcessing, mRemoveXrays, 1,
      mNormParam, mNormDark, NULL, NULL, mNormGain, mNormDMSizeX, mNormDMSizeY, 
      mNormBinning, mNormTop, mNormLeft, mNormBot, mNormRight, mNormImageType, 
      mProcessing);
  
  // Do alignment unless skipping that
  if (!mStackError && mUseFrameAlign && !mAlignError && !skipAlign) {
    if (mEERsumming > 0) {
      useGainArr = mFalconGainRef;
      if (mFoundFalconDefects)
        useDefects = &mFalconDefects;
      useNxGain = mGainSizeX;
      useNyGain = mGainSizeY;
    } else if (mGainp) {
      useGainArr = (float *)mGainp->Array;
      useNxGain = mGainp->SizeX;
      useNyGain = mGainp->SizeY;
      useDefects = &camParam->defects;
    }
    hasDefects = AreDefectsNonEmpty(useDefects);
    ind = mFrameAli->nextFrame(outPtr, 
      (mEERsumming > 0 && !mReadEERantialiased) ? MRC_MODE_BYTE : mImage->getMode(),
      useGainArr, useNxGain, useNyGain, mDarkp ? mDarkp->Array : NULL, mAlignTruncation,
      useDefects, hasDefects ? useNxGain : 0, hasDefects ? useNyGain : 0, 1, 0., 0.);
    if (ind) {
      SEMTrace('1', "Error %d calling framealign nextFrame on frame %d", ind,
        mFileInd + 1);
      mAlignError = FIF_ALIGN_FRAME_ERR;
      mFrameAli->cleanup();
    }
    if (ind && !saving) {
      CleanupAndFinishAlign(saving, param);
      return;
    }
    if (!mAlignError) {
      mNumAligned++;
      mDeletePrev = true;
    }
  }

  // Write the image
  if (!mStackError && saving) {
    if (mRotateFlip) {
      ProcRotateFlip((short *)mRotData, mDivideBy2 ? kSHORT : kUSHORT, mNx, mNy, 
        mRotateFlip, 0, outData, &ind, &val);
    }
    if (mImage2) {

      // Check async saving first,
      CheckAsyncSave();
      // then Start a new async save and swap to other image
      mStartedAsyncSave = mFileInd;
      mWinApp->mBufferManager->StartAsyncSave(mStoreMRC, 
        mUseImage2 > 0 ? mImage2 : mImage, -1, 0);
      mUseImage2 = -mUseImage2;
      ind = 0;

    } else {
      ind = mStoreMRC->AppendImage(mImage);
    }
    if (ind) {
      mStackError = FIF_WRITE_ERR;
    } else {

      // Delete the FEI image now that it is safely stacked, unless asynchronous
      if (!mImage2) {
        mNumStacked++;
        mDeletePrev = true;
      }
      SEMTrace('1', "Frame %d %s added to stack", mFileInd + 1, 
        mImage2 ? "started being" : "");
    }
  }

  // For errors beside no more files, report the error and go for the next frame
  if (mStackError && mStackError != FIF_NO_MORE_FILES)
    SEMTrace('1', "Error dealing with frame %d: %s", mFileInd + 1, 
      errMess[mStackError - 1]);
  mFileInd++;
  if (!saving && skipAlign > 1)
    mStackError = FIF_NO_MORE_FILES;
  if (param && mStackError != FIF_NO_MORE_FILES && (!mStackError || saving)) {
    mWaitStart = GetTickCount();
    mWaitCount = mFileInd < mNumFiles ? 0 : mWaitMaxCount + 1;
    mWinApp->AddIdleTask(TASK_STACK_FALCON, 1, 0);
  }

  // But for no more files, clean up and report result
  if (mStackError == FIF_NO_MORE_FILES)
    CleanupAndFinishAlign(saving, param);
  else if (mStackError && !saving) {
    mAlignError = mStackError;
    CleanupAndFinishAlign(saving, param);
  }
}

// Cleanup at the end of any operations, finish the alignment if doing it and put result
// into saved array for image buffer, call for display of that, give summary line,
// write a com file now if more than one frame was stacked
void CFalconHelper::CleanupAndFinishAlign(bool saving, int async)
{
  CString comPath;
  int err = -1;
  if (mAlignError && mJustAlignNotSave)
    mDeletePrev = false;
  CleanupStacking();
  if (mUseFrameAlign) {
    if (mAlignError) {
      if (!saving)
        mStackError = mAlignError;
    } else {
      FinishFrameAlignment(mSumBinning);
    }
    if (async)
      mCamera->DisplayNewImage(true);
  } else if (mAliComParamInd >= 0 && mNumStacked > 1) {
    comPath = (mCamera->GetComPathIsFramePath() ? mDirectory : 
      mCamera->GetAlignFramesComPath()) + '\\' + mRootname + ".pcm";
    err = WriteAlignComFile(mDirectory + "\\" + mRootname + ".mrc", comPath, 
      mAliComParamInd, mUseGpuForAlign[1], false, mNx, mNy, 0, 0.);
  }
  if (saving && !(mUseFrameAlign && async))
    PrintfToLog("%d of %d frames were stacked successfully%s", mNumStacked, mNumFiles,
      err == 0 ? " and com file for aligning was written" : "");
  if (err > 0)
    PrintfToLog("WARNING: The com file for aligning was not saved: %s",
      SEMCCDErrorMessage(err));
}

// Get the summed image, results and possibly FRC back from frame alignment,
void CFalconHelper::FinishFrameAlignment(int binning)
{
  CArray<FrameAliParams, FrameAliParams> *faParams =
    mCamera->GetFrameAliParams();
  FrameAliParams param;
  int ind, bestFilt, val, nxBin = mNx / binning, nyBin = mNy / binning;
  int rotNx = nxBin, rotNy = nyBin, numPix = nxBin * nyBin;
  bool toFloats = mCamTD->ImageType == kFLOAT;
  float resMean[5], smoothDist[5], rawDist[5], resSD[5], meanResMax[5];
  float maxResMax[5], meanRawMax[5], maxRawMax[5], ringCorrs[26], frcDelta = 0.02f;
  float refSigma = (float)(0.001 * B3DNINT(1000. * param.refRadius2 *
    param.sigmaRatio));
  float crossHalf, crossQuarter, crossEighth, halfNyq;
  float *aliSum = mFrameAli->getFullWorkArray();
  float *xShifts = new float[mNumAligned + 10];
  float *yShifts = new float[mNumAligned + 10];
  short *sAliSum = (mTrimDEsum || mSumNeedsRotFlip) ?
    (short *)aliSum : mCamTD->Array[0];
  unsigned short *usAliSum = (unsigned short *)sAliSum;
  float *fArray = (float *)mCamTD->Array[0];

  if (mFAparamSetInd < 0) {
    param = mContinuousAliParam;
    mFloatScale = mCamera->GetAverageContinAlign() ? (float)(1. / mNumAligned) : 0.f;
  } else
    param = faParams->GetAt(mFAparamSetInd);

  ind = mFrameAli->finishAlignAndSum(param.refRadius2, refSigma, param.stopIterBelow,
    param.groupRefine, (mNumAligned >= param.smoothThresh && param.doSmooth) ? 1 : 0,
    aliSum, xShifts, yShifts, xShifts, yShifts,
    mGettingFRC ? ringCorrs : NULL, frcDelta, bestFilt, smoothDist, rawDist,
    resMean, resSD, meanResMax, maxResMax, meanRawMax, maxRawMax);
  delete[] xShifts;
  delete[] yShifts;
  if (!ind)  {
    mCamTD->FaResMean = resMean[bestFilt];
    mCamTD->FaMaxResMax = maxResMax[bestFilt];
    mCamTD->FaMeanRawMax = meanRawMax[bestFilt];
    mCamTD->FaMaxRawMax = maxRawMax[bestFilt];
    mCamTD->FaRawDist = rawDist[bestFilt];
    mCamTD->FaSmoothDist = smoothDist[bestFilt];
    if (mGettingFRC) {
      mFrameAli->analyzeFRCcrossings(ringCorrs, frcDelta, crossHalf, crossQuarter, 
        crossEighth, halfNyq);
      mCamTD->FaCrossHalf = B3DNINT(K2FA_FRC_INT_SCALE * crossHalf); 
      mCamTD->FaCrossQuarter = B3DNINT(K2FA_FRC_INT_SCALE * crossQuarter);
      mCamTD->FaCrossEighth = B3DNINT(K2FA_FRC_INT_SCALE * crossEighth);
      mCamTD->FaHalfNyq = B3DNINT(K2FA_FRC_INT_SCALE * halfNyq);
    } else {
      mCamTD->FaCrossHalf = mCamTD->FaCrossQuarter = mCamTD->FaCrossEighth = 
        mCamTD->FaHalfNyq = 0;
    }

    // Only old Falcon 2 frames were divided, the advanced scripting frames were
    // just read in and still need that treatment.  In any case, data needs to be clamped
    // and cast as appropropriate for the return type
    if (((mDoingAdvancedFrames || mFAparamSetInd < 0) && mFloatScale > 0) || 
      mCamTD->DE_camType) {
      if (mDivideBy2) {
        for (ind = 0; ind < numPix; ind++) {
          val = B3DNINT(mFloatScale * aliSum[ind]);
          B3DCLAMP(val, -32768, 32767);
          sAliSum[ind] = (short)val;
        }
      } else {
        for (ind = 0; ind < numPix; ind++) {
          val = B3DNINT(mFloatScale * aliSum[ind]);
          B3DCLAMP(val, 0, 65535);
          usAliSum[ind] = (unsigned short)val;
        }
      }
    } else if (mDoingAdvancedFrames && mDivideBy) {
      if (mDivideBy2) {
        for (ind = 0; ind < numPix; ind++) {
          val = B3DNINT(aliSum[ind]) >> mDivideBy;
          B3DCLAMP(val, -32768, 32767);
          sAliSum[ind] = (short)val;
        }
      } else {
        for (ind = 0; ind < numPix; ind++) {
          val = B3DNINT(aliSum[ind]) >> mDivideBy;
          B3DCLAMP(val, 0, 65535);
          usAliSum[ind] = (unsigned short)val;
        }
      }
    } else if (toFloats && !mSumNeedsRotFlip) {

      // FLOATS: This covers only the case where a plugin has done any divide by 2 needed
      // and no float scaling is also entailed.  Other cases will need different handling
      for (ind = 0; ind < numPix; ind++)
        fArray[ind] = aliSum[ind];

    } else if (mDivideBy2) {
      for (ind = 0; ind < numPix; ind++) {
        val = B3DNINT(aliSum[ind]);
        B3DCLAMP(val, -32768, 32767);
        sAliSum[ind] = (short)val;
      }
    } else {
      for (ind = 0; ind < numPix; ind++) {
        val = B3DNINT(aliSum[ind]);
        B3DCLAMP(val, 0, 65535);
        usAliSum[ind] = (unsigned short)val;
      }
    }

    // Trim and get modified nx, ny
    if (mTrimDEsum)
      extractWithBinning(sAliSum, mDivideBy2 ? kSHORT : kUSHORT, nxBin, mTrimXstart, 
        mTrimXend, mTrimYstart, mTrimYend, 1, 
        mSumNeedsRotFlip ? sAliSum : mCamTD->Array[0], 1, &rotNx, &rotNy);

    // If rotating, that last operation was done in place and now rotate into array
    if (mSumNeedsRotFlip)
      rotateFlipImage(sAliSum, B3DCHOICE(toFloats, kFLOAT, mDivideBy2 ? kSHORT : kUSHORT),
        rotNx, rotNy, mAliSumRotFlip, 1, 0, 0, mCamTD->Array[0], &ind, &val, 0);
  } else {
    SEMTrace('1', "Error %d finishing frame alignment", ind);
    mAlignError = FIF_FINISH_ALIGN_ERR;
  }
  mFrameAli->cleanup();
}

// "Busy" test for whether waiting before stacking next frame
int CFalconHelper::StackingWaiting()
{
  if (mProcessingPlugin || SEMTickInterval(mWaitStart) > mWaitInterval || 
    mWaitCount > mWaitMaxCount)
    return 0;
  mWaitCount++;
  return 1;
}

int CFalconHelper::TaskStackingBusy()
{
  CSerialEMApp *serialEM = (CSerialEMApp *)AfxGetApp();
  return serialEM->mFalconHelper->GetStackingFrames() ? 1 : 0;
}

// Check async saving before a new save or at the end
// and if it was one of ours and did not fail, set the flag for deletion.
void CFalconHelper::CheckAsyncSave(void)
{
  mWinApp->mBufferManager->CheckAsyncSaving();
  if (mStartedAsyncSave >= 0) {
    if (mWinApp->mBufferManager->GetImageAsyncFailed())
      SEMTrace('1', "Error in asynchronous save for frame %d", 
      mStartedAsyncSave + 1);
    else {
      if (!mProcessingPlugin)
        mDeleteList[mStartedAsyncSave] = 1;
      mNumStacked++;
    }
  }

}

// Clean up memory when done stacking, plus delete files when asynchronous saving used
void CFalconHelper::CleanupStacking(void)
{
  CString str;

  if (mReadLocally) {
    iiFClose(mFrameFP);
    mFrameFP = NULL;
    if (mJustAlignNotSave) {
      SEMTrace('E', "Removing %s and .xml after alignment", (LPCTSTR)mLocalPath);
      UtilRemoveFile(mLocalPath);
      UtilRemoveFile(mLocalPath.Left(mLocalPath.GetLength() - 3) + "xml");
    }
  } else {

    // If asynchronous save was used, then need to check on it and then do special cleanup
    // of all files that were saved successfully  
    if (mImage2) {
      CheckAsyncSave();
      if (!mProcessingPlugin)
        mPlugFuncs->FIFcleanUp2(mNumFiles, &(mDeleteList[0]));

      // Or do regular cleanup through plugin
    } else if (!mProcessingPlugin)
      mPlugFuncs->FIFcleanUp(mDeletePrev);
  }
  mDeletePrev = false;
  delete mStoreMRC;
  delete mRotData;
  delete mImage;
  delete mImage2;
  mRotData = NULL;
  mStoreMRC = NULL;
  mImage = NULL;
  mImage2 = NULL;
  mStackingFrames = false;
}

// Start processing frames from a plugin.  This is most like Falcon 2 so it will stack and
// align through StackNextTask
int CFalconHelper::ProcessPluginFrames(CString &directory, CString &rootname, 
  ControlSet &conSet, bool save, bool align, int aliParamInd, int divideBy2, float pixel,
  CameraThreadData *camTD)
{
  CameraParameters *camParam = mWinApp->GetActiveCamParam();
  CString str;
  int err;

  // Initialize parameters appropriately
  mProcessingPlugin = true;
  mDoingAdvancedFrames = false;
  mReadLocally = false;
  mNx = mNy = -1;
  mCamTD = camTD;
  mHeadNums[0] = camTD->DMSizeX;
  mHeadNums[1] = camTD->DMSizeY;
  mDirectory = directory;
  mRootname = rootname;
  mDivideBy = 0;
  mDivideBy2 = divideBy2;
  mRotateFlip = 0;
  mAliSumRotFlip = 0;
  mSumNeedsRotFlip = mAliSumRotFlip != 0;
  mPixel = pixel;
  mAliComParamInd = aliParamInd;
  mRotFlipForComFile = mAliSumRotFlip;
  mNumStacked = 0;
  mNumAligned = 0;
  mAlignError = 0;
  mStartedAsyncSave = -1;
  str = mDirectory + "\\" + mRootname + ".mrc";
  mJustAlignNotSave = align && !save;
  mLastFrameDir = directory;
  mNumFiles = B3DNINT(camTD->Exposure / camTD->FrameTime);
  if ((err = MakeBackupIfFileExists(str)) != 0)
    return err;

  // Set up frame alignment
  mUseFrameAlign = align ? 1 : 0;
  if (align) {
    mFAparamSetInd = conSet.faParamSetInd;
    if ((err = SetupFrameAlignment(conSet, camParam, mGpuMemory, mUseGpuForAlign, 
      mNumFiles)) != 0)
      return err;
  }

  // Set up for normalizing here, but if only alignment is being done and conditions
  // are satisfied for using dark and gain refs in framealign, cancel that
  mNeedNormHere = conSet.processing != camTD->Processing;
  mProcessing = conSet.processing;
  mRemoveXrays = conSet.removeXrays;
  if (mNeedNormHere && align && !save) {
    mNeedNormHere = !mCamera->CanFramealignProcessSubarea(&conSet, &mDarkp,
      &mGainp);
    SEMTrace('1',"Frames will be normalized %s", mNeedNormHere ? "in cam controller" : 
      "in framealign");
  }

  // Save EVERYTHING needed for a processing call in case a single shot occurs
  if (mNeedNormHere) {
    mCamera->GetProcessingRefs(&mNormDark, &mNormGain);
    mCamera->GetProcessingCoords(mNormBinning, mNormTop, mNormLeft, mNormBot, mNormRight);
    mNormDMSizeX = mCamTD->DMSizeX;
    mNormDMSizeY = mCamTD->DMSizeY;
    mNormImageType = mCamTD->ImageType;
    mNormParam = camParam;
  }
  mFileInd = 0;
  mStackingFrames = true;
  mWinApp->AddIdleTask(TASK_STACK_FALCON, 1, 0);
  return 0;
}


// Do frame alignment by reading a file: just for DE right now
int CFalconHelper::AlignFramesFromFile(CString filename, ControlSet &conSet, 
  int rotateFlip, int divideBy2, float scaling, int &numFrames, CameraThreadData *td)
{
  CameraParameters *camParam = mWinApp->GetActiveCamParam();
  int dsize, csize;
  CString str;
  char errStr[160];
  int hwSuperDiv = SuperResHardwareBinDivisor(camParam, &conSet);
  int top, bottom, left, right, fullSizeX, fullSizeY, frameX, frameY, fullFileX;
  bool hardwareROI = (camParam->CamFlags & DE_HAS_HARDWARE_ROI) && conSet.magAllShots;
  mAlignError = 0;
  mNumAligned = 0;
  mCamTD = td;
  mDoingAdvancedFrames = false;
  mAlignSubset = false;

  // Open file, read header
  mFrameFP = iiFOpen((LPCTSTR)filename, "rb");
  if (!mFrameFP) {
    _get_errno(&csize);
    strerror_s(errStr, 160, csize);
    str = CString("Error opening frame file ") + filename + ": " + errStr;
  } else if (mrc_head_read(mFrameFP, &mMrcHeader)) {
    iiFClose(mFrameFP);
    str = CString("Error reading frame file ") + filename + ": " + b3dGetError();
  }
  if (!str.IsEmpty()) {
    SEMMessageBox(str);
    return 1;
  }
  mNx = mMrcHeader.nx;
  mNy = mMrcHeader.ny;

  // This builds in the assumption that the DE file IS inverted AND that we want 
  // inverted images in here anyway, in case it is eventually recognized as inverted
  mMrcHeader.yInverted = 0;

  GetSavedFrameSizes(camParam, &conSet, frameX, frameY, false);
  fullFileX = (camParam->sizeX * 2) / hwSuperDiv;
  if (frameY != mNy || (!hardwareROI && frameX != mNx) || 
    (hardwareROI && frameX != mNx && fullFileX != mNx)) {
      str.Format("Saved frames are %d x %d, not the expected size of %d x %d; cannot "
        "align the frames", mNx, mNy, hardwareROI ? fullFileX : frameX, frameY);
      SEMMessageBox(str);
      iiFClose(mFrameFP);
      return 1;
  }
  mDEframeNeedsTrim = hardwareROI && frameX < fullFileX;

  // Save many parameters including trim size and need to trim
  mNumFiles = mMrcHeader.nz;
  numFrames = mAlignEnd = mNumFiles;
  mAlignStart = 1;
  mDivideBy2 = divideBy2;
  B3DCLAMP(rotateFlip, 0, 7);
  mAliSumRotFlip = rotateFlip;

  /*// DE frames are read in right-handed and require inversion after.  rotateflip first 
  // maps r/f through the right-handed map that maps 6 to 6, then through the invertAfter
  // map that maps 6 to 0.  So 6 needs no operation*/
  mSumNeedsRotFlip = mAliSumRotFlip != 0;
  mFloatScale = scaling * (divideBy2 ? 0.5f : 1.f);

  // The alignment will do the binning but not the rotation.  If trimming is needed, it
  // needs to be native full-chip coordinates but binned by final binning
  left = conSet.left;
  right = conSet.right;
  top = conSet.top;
  bottom = conSet.bottom;
  frameX = right - left;
  frameY = bottom - top;
  fullSizeX = camParam->sizeX;
  fullSizeY = camParam->sizeY;
  CorDefUserToRotFlipCCD(rotateFlip, 1, fullSizeX, fullSizeY, frameX, frameY, top, left,
    bottom, right);

  /*// But native coordinates need to be inverted in Y since the right-handed image will be
  // trimmed
  frameY = fullSizeY - top;
  top = fullSizeY - bottom;
  bottom = frameY;*/
  mTrimXstart = left / conSet.binning;
  mTrimXend = right / conSet.binning - 1;
  mTrimYstart = top / conSet.binning;
  mTrimYend = bottom / conSet.binning - 1;
  mTrimDEsum = (conSet.left > 0 || conSet.right < camParam->sizeX ||
    conSet.top > 0 || conSet.bottom < camParam->sizeY) && !hardwareROI;

  if (mDEframeNeedsTrim) {
    mFrameTrimStart = (2 * left) / hwSuperDiv;
    mFrameTrimEnd = (2 * right) / hwSuperDiv - 1;
    mNx = mFrameTrimEnd + 1 - mFrameTrimStart;
  }

  // Get array for reading in and set up the alignment
  mrc_getdcsize(mMrcHeader.mode, &dsize, &csize);
  NewArray(mRotData, short, ((size_t)mNx * mNy * dsize) / 2 + 10);
  if (!mRotData) {
    SEMMessageBox("Error allocating array for reading in frames to align");
    iiFClose(mFrameFP);
    return 1;
  }
  mFAparamSetInd = conSet.faParamSetInd;
  if (SetupFrameAlignment(conSet, camParam, mGpuMemory, mUseGpuForAlign, mNumFiles)) {
    delete mRotData;
    mRotData = NULL;
    iiFClose(mFrameFP);
    return 1;
  }

  // Set an idle task for handling even the first frame so error reporting flows properly
  mFileInd = mAlignStart - 1;
  mWinApp->AddIdleTask(TASK_ALIGN_DE_FRAMES, 0, 0);
  return 0;
}

// Read the next frame and align it
void CFalconHelper::AlignNextFrameTask(int param)
{
  int ind;
  IloadInfo li;
  mrc_init_li(&li, NULL);
  mrc_init_li(&li, &mMrcHeader);
  if (mDEframeNeedsTrim) {
    li.xmin = mFrameTrimStart;
    li.xmax = mFrameTrimEnd;
  }
  if (mrcReadZ(&mMrcHeader, &li, (unsigned char *)mRotData, mFileInd)) {
    mAlignError = FIF_DE_READ_ERR;
    SEMTrace('1', "Error reading frame %d: %s", mFileInd, b3dGetError());
  }

  // Align if no error
  if (!mAlignError) {
    ind = mFrameAli->nextFrame(mRotData, mMrcHeader.mode, NULL, mNx, mNy, 
      NULL, 0.,  // Truncation limit...
      NULL, 0, 0, 1, 0., 0.);
    if (ind) {
      SEMTrace('1', "Error %d calling framealign nextFrame on frame %d", ind, 
        mFileInd + 1);
      mAlignError = FIF_ALIGN_FRAME_ERR;
    }
  } 

  // Go on to next if no error
  if (!mAlignError) {
    mFileInd++;
    mNumAligned++;
    if (mFileInd < mAlignEnd) {
      mWinApp->AddIdleTask(TASK_ALIGN_DE_FRAMES, 0, 0);
      return;
    }
  }

  // Close file and finish up one way or another
  delete mRotData;
  mRotData = NULL;
  iiFClose(mFrameFP);
  if (mAlignError)
    mFrameAli->cleanup();
  else
    FinishFrameAlignment(mSumBinning);

  mCamera->DisplayNewImage(true);
}

// Set up frame alignment for continuous mode images
int CFalconHelper::SetupContinuousAlign(ControlSet &conSet, CameraThreadData *camTD, 
  int divideBy2, int numExpected)
{
  CameraParameters *camParam = mWinApp->GetActiveCamParam();
  mDoingAdvancedFrames = false;
  mNx = mHeadNums[0] = camTD->DMSizeX;
  mNy = mHeadNums[1] = camTD->DMSizeY;
  mDivideBy = 0;
  mDivideBy2 = divideBy2;
  mCamTD = camTD;
  mFAparamSetInd = -1;
  mNumAligned = 0;
  mAliSumRotFlip = 0;
  mSumNeedsRotFlip = false;
  mUseFrameAlign = 1;
  B3DCLAMP(mContinuousAliParam.aliBinning, 1, 16);
  B3DCLAMP(mContinuousAliParam.rad2Filt1, 0.f, 0.5f);
  if (mContinuousAliParam.numAllVsAll < -1)
    mContinuousAliParam.strategy = FRAMEALI_HALF_PAIRWISE;
  else if (mContinuousAliParam.numAllVsAll < 0)
    mContinuousAliParam.strategy = FRAMEALI_ALL_PAIRWISE;
  else if (mContinuousAliParam.numAllVsAll > 0)
    mContinuousAliParam.strategy = FRAMEALI_PAIRWISE_NUM;
  else
    mContinuousAliParam.strategy = FRAMEALI_ACCUM_REF;
  return SetupFrameAlignment(conSet, camParam, mGpuMemory, &mGpuForContinuousAli, 
    numExpected);
}

// Pass the next continuous image to framealign
int CFalconHelper::NextContinuousFrame()
{
  int ind = mFrameAli->nextFrame(mCamTD->Array[0], 
    mDivideBy2 ? MRC_MODE_SHORT : MRC_MODE_USHORT, NULL, mNx, mNy, NULL, 0.,
    NULL, 0, 0, 1, 0., 0.);
  if (ind)
    SEMTrace('1', "Error %d calling framealign nextFrame on frame %d", ind,
      mNumAligned + 1);
  mNumAligned++;
  return ind;
}


// Add any new frames to the file map under a unique number
int CFalconHelper::BuildFileMap(CString localPath, CString &directory)
{
  if (localPath.IsEmpty())
    localPath = directory;

  return mPlugFuncs->FIFbuildFileMap((LPCTSTR)localPath, &mNumFiles, &mHeadNums[0],
    &mHeadNums[1]);
}

const char * CFalconHelper::GetErrorString(int code)
{
  if (code <= 0 || code >= FIF_LAST_CODE)
    return "";
  return errMess[code - 1];
}

// Divide the given number of readouts among the current number of frames
void CFalconHelper::DistributeSubframes(ShortVec &summedFrameList, int numReadouts, 
  int newFrames, FloatVec &userFrameFrac, FloatVec &userSubframeFrac,
  bool aligningInFalcon)
{
  float fracLeft = 1., sum1 = 0., sum2 = 0.;
  int ind, frames, subframesLeft, framesLeft, numBlocks, blocksLeft, frameTot = 0;
  int perFrame, extra, numFrames, alignFraction, size;
  ShortVec framesPerBlock, subframesPerBlock;
  if (!summedFrameList.size())
    return;

  // If aligning in the falcon, see if all frames are single readouts, and if so
  // just keep it that way and return; otherwise work with "align fractions" instead of
  // single readouts
  if (aligningInFalcon) {
    alignFraction = mWinApp->mCamera->GetFalcon3AlignFraction();
    extra = 0;
    for (ind = 0; ind < (int)summedFrameList.size(); ind += 2) {
      if (summedFrameList[ind + 1] != 1)
        extra = 1;
      summedFrameList[ind + 1] = B3DMAX(1, B3DNINT((float)summedFrameList[ind + 1]) / 
        alignFraction);
    }
    if (!extra) {
      userFrameFrac.resize(1);
      userFrameFrac[0] = 1.;
      userSubframeFrac.resize(1);
      userSubframeFrac[0] = 1.;
      summedFrameList.resize(2);
      summedFrameList[0] = numReadouts;
      summedFrameList[1] = 1;
      return;
    }
    numReadouts = B3DMAX(1, B3DNINT((float)numReadouts / alignFraction));
  }
  numFrames = B3DMIN(numReadouts, newFrames);

  // If there are too many fractions, renormalize the smaller number of them
  if (numFrames < (int)userFrameFrac.size()) {
    userFrameFrac.resize(numFrames);
    for (ind = 0; ind < numFrames; ind++) {
      sum1 += userFrameFrac[ind];
      sum2 += userSubframeFrac[ind];
    }
    for (ind = 0; ind < numFrames; ind++) {
      userFrameFrac[ind] /= sum1;
      userSubframeFrac[ind] /= sum2;
    }
  }

  // First apportion total frames among the blocks
  framesLeft = numFrames;
  numBlocks = (int)userFrameFrac.size();
  for (ind = 0; ind < numBlocks; ind++) {
    frames = B3DNINT(B3DMAX(1., userFrameFrac[ind] * framesLeft / fracLeft));
    blocksLeft = numBlocks - 1 - ind;
    if (framesLeft - frames < blocksLeft)
      frames = B3DMAX(1, framesLeft - blocksLeft);
    framesPerBlock.push_back(frames);
    fracLeft -= userFrameFrac[ind];
    framesLeft -= frames;
  }

  // Now distribute subframes among blocks with more constraints
  fracLeft = 1.;
  framesLeft = numFrames;
  subframesLeft = numReadouts;
  for (ind = 0; ind < numBlocks; ind++) {
    frames = B3DNINT(B3DMAX(framesPerBlock[ind], userSubframeFrac[ind] * subframesLeft / 
      fracLeft));
    framesLeft -= framesPerBlock[ind];
    if (subframesLeft - frames < framesLeft)
      frames = B3DMAX(framesPerBlock[ind], subframesLeft - framesLeft);
    subframesPerBlock.push_back(frames);
    fracLeft -= userSubframeFrac[ind];
    subframesLeft -= frames;
  }
 
  // Now there are one or two list entries per block
  summedFrameList.clear();
  for (ind = 0; ind < numBlocks; ind++) {
    perFrame = subframesPerBlock[ind] / framesPerBlock[ind];
    extra = subframesPerBlock[ind] % framesPerBlock[ind];


    // Before adding a new entry, see if it matches the per frame of the previous one
    // and if so add it to that
    size = (int)summedFrameList.size();
    if (size && summedFrameList[size - 1] == perFrame) {
      summedFrameList[size - 2] += framesPerBlock[ind] - extra;
    } else {
      summedFrameList.push_back(framesPerBlock[ind] - extra);
      summedFrameList.push_back(perFrame);
    }

    // Do the same with the extra, add to previous entry if possible
    if (extra) {
      size = (int)summedFrameList.size();
      if (size && summedFrameList[size - 1] == perFrame + 1) {
        summedFrameList[size - 2] += extra;
      } else {
        summedFrameList.push_back(extra);
        summedFrameList.push_back(perFrame + 1);
      }
    }
  }

  // Multiply by align fraction size now if aligning in Falcon
  if (aligningInFalcon) {
    for (ind = 0; ind < (int)summedFrameList.size(); ind += 2)
      summedFrameList[ind + 1] *= alignFraction;
  }
}

float CFalconHelper::AdjustForExposure(ShortVec &summedFrameList, int numSkipBefore,
    int numSkipAfter, float exposure, float readoutInterval, FloatVec &userFrameFrac, 
    FloatVec &userSubframeFrac, bool aligningInFalcon)
{
  int newFrames, curTotal = 0;
  int numFrames = B3DMAX(1, B3DNINT(exposure / readoutInterval) - 
    (numSkipBefore + numSkipAfter));
  newFrames = GetFrameTotals(summedFrameList, curTotal);
  if (numFrames != curTotal || aligningInFalcon)
    DistributeSubframes(summedFrameList, numFrames, newFrames, userFrameFrac, 
    userSubframeFrac, aligningInFalcon);
  return (numFrames + numSkipBefore + numSkipAfter) * readoutInterval;
}

// Adjusts frame sums for exposure if appropriate
// This should be called only for RECORD or an argument added
float CFalconHelper::AdjustSumsForExposure(CameraParameters *camParams, 
  ControlSet *conSet, float exposure, int consNum)
{
  bool falconCanSave = IS_FALCON2_3_4(camParams) && 
    mCamera->GetMaxFalconFrames(camParams) && 
    (mCamera->GetFrameSavingEnabled() || FCAM_ADVANCED(camParams));
  if (falconCanSave || (mCamera->IsConSetSaving(conSet, consNum, camParams, true) && 
    conSet->sumK2Frames))
    return AdjustForExposure(conSet->summedFrameList, 
      falconCanSave ? conSet->numSkipBefore : 0, falconCanSave ? conSet->numSkipAfter : 0, 
      exposure,
      falconCanSave ? mCamera->GetFalconFractionDivisor(camParams) : conSet->frameTime,
      conSet->userFrameFractions, conSet->userSubframeFractions, falconCanSave && 
      FCAM_CAN_ALIGN(camParams) && conSet->alignFrames && !conSet->useFrameAlign);
  return exposure;
}

// Returns the number of summed frames given the list, and also the number of camera
// frames in totalSubFrames, all limited by maxFrames if positive (default -1)
int CFalconHelper::GetFrameTotals(ShortVec &summedFrameList, int &totalSubframes,
  int maxFrames)
{
  int frameTot = 0;
  totalSubframes = 0;
  for (int ind = 0; ind < (int)summedFrameList.size() / 2; ind++) {
    for (int sumf = 0; sumf < summedFrameList[ind * 2]; sumf++) {
      frameTot++;
      totalSubframes += summedFrameList[ind * 2 + 1];
      if (maxFrames > 0 && totalSubframes >= maxFrames) {
        totalSubframes = maxFrames;
        return frameTot;
      }
    }
  }
  return frameTot;
}

// When aligning a subset of summed frames, count up actual frames in the range of the
// subset and compute their exposure time
float CFalconHelper::AlignedSubsetExposure(ShortVec &summedFrameList, float frameTime, 
  int subsetStart, int subsetEnd, int maxFrames)
{
  int ind, sumf, alignedTot = 0, frameTot = 0, totalSubframes = 0;
  for (ind = 0; ind < (int)summedFrameList.size() / 2; ind++) {
    for (sumf = 0; sumf < summedFrameList[ind * 2]; sumf++) {
      frameTot++;
      totalSubframes += summedFrameList[ind * 2 + 1];
      if (frameTot >= subsetStart && frameTot <= subsetEnd)
        alignedTot += summedFrameList[ind * 2 + 1];
      if (maxFrames > 0 && totalSubframes >= maxFrames) {
        alignedTot -= totalSubframes - maxFrames;
        return (float)(alignedTot * frameTime);
      }
      if (frameTot >= subsetEnd)
        return (float)(alignedTot * frameTime);
    }
  }
  return (float)(alignedTot * frameTime);     
}

/*
 * Write a com file for alignment with alignframes
 */
int CFalconHelper::WriteAlignComFile(CString inputFile, CString comName, int faParamInd, 
  int useGPU, bool ifMdoc, int frameX, int frameY, int EERsumming, float pixelSize)
{
  CString comStr, strTemp, aliHead, inputPath, relPath, outputRoot, outputExt, temp,temp2;
  CArray<FrameAliParams, FrameAliParams> *faParams = 
    mCamera->GetFrameAliParams();
  FrameAliParams param; 
  int ind, superFac = 1, error = 0;
  float fSuperFac = 1.f, radius2[4];
  int numAllVsAll, groupSize, refineIter, doSpline, numFilters;
  B3DCLAMP(faParamInd, 0, (int)faParams->GetSize() - 1);
  param = faParams->GetAt(faParamInd);
  param.multAliBinByEERfac = EERsumming > 0;
  if (EERsumming > 0) {
    superFac = GetEERsuperFactor(param.EERsuperRes);
    fSuperFac = (float)superFac;
    frameX *= superFac;
    frameY *= superFac;
    pixelSize /= superFac;
  }
  numAllVsAll = mCamera->NumAllVsAllFromFAparam(param, mNumStacked, groupSize, 
    refineIter, doSpline, numFilters, radius2);
  radius2[0] /= fSuperFac;

  // Translate the strategy options
  if (param.strategy == FRAMEALI_HALF_PAIRWISE)
    numAllVsAll = -2;
  else if (param.strategy == FRAMEALI_ALL_PAIRWISE)
    numAllVsAll = -1;

  // Do all the easy options
  strTemp.Format("$alignframes -StandardInput\n"
    "UseGPU %d\n"
    "PairwiseFrames %d\n"
    "GroupSize %d\n"
    "AlignAndSumBinning %d %d\n"
    "AntialiasFilter %d\n"
    "RefineAlignment %d\n"
    "StopIterationsAtShift %f\n"
    "ShiftLimit %d\n"
    "MinForSplineSmoothing %d\n"
    "FilterRadius2 %f\n"
    "FilterSigma2 %f\n"
    "VaryFilter %f", useGPU ? 0 : -1, numAllVsAll, param.useGroups ? param.groupSize : 1, 
    UtilGetFrameAlignBinning(param, frameX, frameY), superFac > 2 ? 2 : 1, 
    param.antialiasType, refineIter, param.stopIterBelow * fSuperFac,
    param.shiftLimit * superFac, param.doSmooth ? param.smoothThresh : 0, radius2[0], 
    radius2[0] * param.sigmaRatio, radius2[0]);
  comStr = strTemp;  
  for (ind = 1; ind < numFilters; ind++) {
    if (radius2[ind] > 0) {
      strTemp.Format(" %f", radius2[ind] / fSuperFac);
      comStr += strTemp;
    }
  }
  comStr += "\n";
  if (param.refRadius2 > 0) {
    strTemp.Format("RefineRadius2 %f\n", param.refRadius2 / fSuperFac);
    comStr += strTemp;
  }
  if (param.hybridShifts)
    comStr += "UseHybridShifts 1\n";
  if (param.groupRefine)
    comStr += "RefineWithGroupSums 1\n";
  if (param.outputFloatSums)
    comStr += "ModeToOutput 2\n";
  if (EERsumming > 0) {
    strTemp.Format("EERSuperResZSumPadding %d %d 1\n", param.EERsuperRes, EERsumming);
    comStr += strTemp;
    if (!mFalconRefName.IsEmpty())
      comStr += "GainReferenceFile " + mFalconRefName + "\n";
    strTemp.Format("ScalingOfSum %f\n", mLastEERcountScaling);
    comStr += strTemp;
    mLastUseOfFalconRef = mWinApp->MinuteTimeStamp();
  }
  if (pixelSize > 0.) {
    strTemp.Format("PixelSize %f\n", pixelSize);
    comStr += strTemp;
  }

  if (param.alignSubset) {
    strTemp.Format("StartingEndingFrames %d %d\n", param.subsetStart,
      param.subsetEnd);
    comStr += strTemp;
  }
  if (mRotFlipForComFile) {
    strTemp.Format("SumRotationAndFlip %d\n", mRotFlipForComFile);
    comStr += strTemp;
  }

  // If input is an mdoc file, copy it to frame location and strip path from name
  if (ifMdoc) {
    UtilSplitPath(inputFile, temp, temp2);
    temp = mLastFrameDir + '\\' + temp2;
    if (!CopyFile((LPCTSTR)inputFile, (LPCTSTR)temp, false))
      return -1;
    inputFile = temp2;
  }

  // get the relative path and make sure it is OK   
  UtilSplitPath(comName, aliHead, temp);
  SEMTrace('E', "com %s  alihead %s  lastframe %s", (LPCTSTR)comName, (LPCTSTR)aliHead,
    (LPCTSTR)mLastFrameDir);
  if (UtilRelativePath(aliHead, mLastFrameDir, relPath))
    return MAKECOM_NO_REL_PATH;

  // Set input file with the relative path and the right option
  inputPath = relPath + inputFile;
  comStr += (ifMdoc ? "MetadataFile " : "InputFile ") + inputPath + "\n";
  if (ifMdoc && relPath.GetLength())
    comStr += "PathToFramesInMdoc " + relPath + "\n";
  if (ifMdoc)
    comStr += "AdjustAndWriteMdoc 1\n";

  // Get the output file name, take 2 extension for an mdoc or replace .tif by .mrc
  UtilSplitExtension(inputFile, outputRoot, outputExt);
  if (ifMdoc) {
    temp = outputRoot;
    UtilSplitExtension(temp, outputRoot, temp2);
    if (temp2.GetLength())
      outputExt = temp2;
  } else if (outputExt == ".tif" || outputExt == ".mrcs" || outputExt == ".eer")
    outputExt = ".mrc";
  comStr += "OutputImageFile " + outputRoot + "_ali" + outputExt + "\n";

  // Write the file
  error = UtilWriteTextFile(comName, comStr);
  if (error == 1)
    error = OPEN_COM_ERROR;
  else if (error == 2)
    error = WRITE_COM_ERROR;
  return error;
}

// Return the size that frames will be saved for the given camera and parameters
// For K2/K3, acquiredSize should be true to get the size in the plugin instead of the
// one actually saved, if they differ
void CFalconHelper::GetSavedFrameSizes(CameraParameters *camParams, 
  const ControlSet *conSet, int &frameX, int &frameY, bool acquiredSize)
{
  int superResDiv = (IS_SUPERRES(camParams, conSet->K2ReadMode) && 
    !mCamera->IsK3BinningSuperResFrames(conSet, camParams)) ? 1 : 2;
  BOOL maybeSwap = false;
  if (camParams->K2Type) {
    if (!acquiredSize && conSet->processing == GAIN_NORMALIZED && 
      !mCamera->GetSaveUnnormalizedFrames() && mCamera->GetSaveSuperResReduced())
      superResDiv = 2;
    frameX = camParams->sizeX / superResDiv;
    frameY = camParams->sizeY / superResDiv;
    if (mCamera->GetPluginVersion(camParams) >= PLUGIN_CAN_SAVE_SUBAREAS) {
      frameX = (conSet->right - conSet->left) / superResDiv;
      frameY = (conSet->bottom - conSet->top) / superResDiv;
    }
    maybeSwap = mCamera->GetSkipK2FrameRotFlip();
  } else if (camParams->FEItype) {
    frameX = (conSet->right - conSet->left) / conSet->binning;
    frameY = (conSet->bottom - conSet->top) / conSet->binning;
    maybeSwap = FCAM_ADVANCED(camParams) && camParams->FEItype != FALCON4_TYPE &&
      !(camParams->FEItype == FALCON3_TYPE && mCamera->GetRotFlipInFalcon3ComFile() >= 0);
    if (mCamera->IsSaveInEERMode(camParams, conSet)) {
      frameX = camParams->sizeX;
      frameY = camParams->sizeY;
      maybeSwap = true;
    }
  } else if (camParams->canTakeFrames) {
    frameX = camParams->sizeX / conSet->binning;
    frameY = camParams->sizeY / conSet->binning;
    if (camParams->OneViewType)
      maybeSwap = mCamera->GetSkipK2FrameRotFlip();
  } else {
    superResDiv = SuperResHardwareBinDivisor(camParams, conSet);
    frameX = (camParams->sizeX * 2) / superResDiv;
    frameY = (camParams->sizeY * 2) / superResDiv;
    if ((camParams->CamFlags & DE_HAS_HARDWARE_ROI) && conSet->magAllShots) {
      frameX = 2 * (conSet->right - conSet->left) / superResDiv;
      frameY = 2 * (conSet->bottom - conSet->top) / superResDiv;
    }
    maybeSwap = true;
  }
  if (maybeSwap && (camParams->rotationFlip % 2 != 0)) {
    superResDiv = frameX;
    frameX = frameY;
    frameY = superResDiv;
  }
}

// For a DE camera, returns a binning divisor to apply to coordinates and sizes times 2
int CFalconHelper::SuperResHardwareBinDivisor(CameraParameters *camParams, 
  const ControlSet *conSet)
{
  int superResDiv = B3DCHOICE((camParams->CamFlags & DE_CAM_CAN_COUNT) && 
    conSet->K2ReadMode == SUPERRES_MODE, 1, 2);
  int hwBin = B3DCHOICE((camParams->CamFlags & DE_HAS_HARDWARE_BIN) && conSet->boostMag &&
      conSet->binning > 1, 2, 1);
  return superResDiv * hwBin;
}

// Given a super-res value, possibly out of bounds, it returns the factor, 1, 2, or 4
int CFalconHelper::GetEERsuperFactor(int superRes)
{
  int superFactors[] = {1, 2, 4};
  B3DCLAMP(superRes, 0, 2);
  return superFactors[superRes];
}

// Returns true if the defects are non-NULL and have any bad items or nonzero "usable's"
bool CFalconHelper::AreDefectsNonEmpty(CameraDefects *defects)
{
  return (defects && (defects->usableBottom || defects->usableTop || defects->usableLeft 
    || defects->usableRight || defects->badColumnStart.size() || 
    defects->badRowStart.size() || defects->badPixelX.size() || 
    defects->partialBadCol.size() || defects->partialBadRow.size()));
}