LoadFITS.cpp

#include "MantidDataHandling/LoadFITS.h"
#include "MantidAPI/MultipleFileProperty.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/RegisterFileLoader.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/UnitFactory.h"
#include <boost/algorithm/string.hpp>
#include <Poco/BinaryReader.h>
#include <fstream>

using namespace Mantid::DataHandling;
using namespace Mantid::DataObjects;
using namespace Mantid::API;
using namespace Mantid::Kernel;
using namespace std;
using namespace boost;
using Poco::BinaryReader;

namespace {
static const std::string BIT_DEPTH_NAME = "BitDepthName";
static const std::string ROTATION_NAME = "RotationName";
static const std::string AXIS_NAMES_NAME = "AxisNames";
static const std::string IMAGE_KEY_NAME = "ImageKeyName";
static const std::string HEADER_MAP_NAME = "HeaderMapFile";

/**
* Used with find_if to check a string isn't a fits file (by checking extension)
* @param s string to check for extension
* @returns bool Value indicating if the string ends with .fits or not
*/
bool IsNotFits(std::string s) {
  std::string tmp = s;
  to_lower(tmp);
  return !ends_with(tmp, ".fits");
}
}

namespace Mantid {
namespace DataHandling {
// Register the algorithm into the AlgorithmFactory
DECLARE_FILELOADER_ALGORITHM(LoadFITS);

/**
* Return the confidence with with this algorithm can load the file
* @param descriptor A descriptor for the file
* @returns An integer specifying the confidence level. 0 indicates it will not
* be used
*/
int LoadFITS::confidence(Kernel::FileDescriptor &descriptor) const {
  // Should really improve this to check the file header (of first file at
  // least) to make sure it contains the fields wanted
  return (descriptor.extension() == ".fits" || descriptor.extension() == ".fit")
             ? 80
             : 0;
}

/**
* Initialise the algorithm. Declare properties which can be set before execution
* (input) or
* read from after the execution (output).
*/
void LoadFITS::init() {
  // Specify file extensions which can be associated with a FITS file.
  std::vector<std::string> exts, exts2;

  // Declare the Filename algorithm property. Mandatory. Sets the path to the
  // file to load.
  exts.clear();
  exts.push_back(".fits");
  exts.push_back(".fit");

  exts2.push_back(".*");

  declareProperty(new MultipleFileProperty("Filename", exts),
                  "The input filename of the stored data");

  declareProperty(new API::WorkspaceProperty<API::Workspace>(
      "OutputWorkspace", "", Kernel::Direction::Output));

  declareProperty(
      new PropertyWithValue<int>("ImageKey", -1, Kernel::Direction::Input),
      "Image type to set these files as. 0=data image, 1=flat field, 2=open "
      "field, -1=use the value from FITS header.");

  declareProperty(new PropertyWithValue<string>(BIT_DEPTH_NAME, "BITPIX",
                                                Kernel::Direction::Input),
                  "Name for the pixel bit depth header key.");
  declareProperty(new PropertyWithValue<string>(ROTATION_NAME, "ROTATION",
                                                Kernel::Direction::Input),
                  "Name for the rotation header key.");
  declareProperty(
      new PropertyWithValue<string>(AXIS_NAMES_NAME, "NAXIS1,NAXIS2",
                                    Kernel::Direction::Input),
      "Names for the axis header keys, comma separated string of all axis.");
  declareProperty(new PropertyWithValue<string>(IMAGE_KEY_NAME, "IMAGEKEY",
                                                Kernel::Direction::Input),
                  "Names for the image type, key.");

  declareProperty(
      new FileProperty(HEADER_MAP_NAME, "", FileProperty::OptionalDirectory, "",
                       Kernel::Direction::Input),
      "A file mapping header keys to the ones used by ISIS [line separated "
      "values in the format KEY=VALUE, e.g. BitDepthName=BITPIX ");
}

/**
* Execute the algorithm.
*/
void LoadFITS::exec() {
  // Init header info - setup some defaults just in case
  m_headerScaleKey = "BSCALE";
  m_headerOffsetKey = "BZERO";
  m_headerBitDepthKey = "BITPIX";
  m_headerImageKeyKey = "IMAGEKEY";
  m_headerRotationKey = "ROTATION";
  m_mapFile = "";
  m_headerAxisNameKeys.push_back("NAXIS1");
  m_headerAxisNameKeys.push_back("NAXIS2");

  mapHeaderKeys();

  // Create FITS file information for each file selected
  std::vector<std::string> paths;
  string fName = getPropertyValue("Filename");
  boost::split(paths, fName, boost::is_any_of(","));
  m_baseName = "";
  m_spectraCount = 0;

  // If paths contains a non fits file, assume (for now) that it contains
  // information about the rotations
  std::string rotFilePath = "";
  std::vector<std::string>::iterator it =
      std::find_if(paths.begin(), paths.end(), IsNotFits);
  if (it != paths.end()) {
    rotFilePath = *it;
    paths.erase(it);
  }
  vector<FITSInfo> allHeaderInfo;
  allHeaderInfo.resize(paths.size());

  // Check each header is valid for this loader, - standard (no extension to
  // FITS), and has two axis
  bool headerValid = true;

  for (size_t i = 0; i < paths.size(); ++i) {
    allHeaderInfo[i].extension = "";
    allHeaderInfo[i].filePath = paths[i];
    // Get various pieces of information from the file header which are used to
    // create the workspace
    if (parseHeader(allHeaderInfo[i])) {
      // Get and convert specific standard header values which will help when
      // parsing the data
      // BITPIX, NAXIS, NAXISi (where i = 1..NAXIS, e.g. NAXIS2 for two axis),
      // TOF, TIMEBIN, N_COUNTS, N_TRIGS
      try {
        string tmpBitPix = allHeaderInfo[i].headerKeys[m_headerBitDepthKey];
        if (boost::contains(tmpBitPix, "-")) {
          boost::erase_all(tmpBitPix, "-");
          allHeaderInfo[i].isFloat = true;
        } else {
          allHeaderInfo[i].isFloat = false;
        }

        // Add the image key, use the property if it's not -1, otherwise use the
        // header value
        allHeaderInfo[i].imageKey =
            boost::lexical_cast<int>(getPropertyValue("ImageKey"));
        if (allHeaderInfo[i].imageKey == -1) {
          allHeaderInfo[i].imageKey = boost::lexical_cast<int>(
              allHeaderInfo[i].headerKeys[m_headerImageKeyKey]);
        }

        allHeaderInfo[i].bitsPerPixel = lexical_cast<int>(tmpBitPix);
        allHeaderInfo[i].numberOfAxis =
            static_cast<int>(m_headerAxisNameKeys.size());

        for (int j = 0;
             allHeaderInfo.size() > i && j < allHeaderInfo[i].numberOfAxis;
             ++j) {
          allHeaderInfo[i].axisPixelLengths.push_back(lexical_cast<size_t>(
              allHeaderInfo[i].headerKeys[m_headerAxisNameKeys[j]]));
        }

        // m_allHeaderInfo[i].tof =
        // lexical_cast<double>(m_allHeaderInfo[i].headerKeys["TOF"]);
        // m_allHeaderInfo[i].timeBin =
        // lexical_cast<double>(m_allHeaderInfo[i].headerKeys["TIMEBIN"]);
        // m_allHeaderInfo[i].countsInImage = lexical_cast<long
        // int>(m_allHeaderInfo[i].headerKeys["N_COUNTS"]);
        // m_allHeaderInfo[i].numberOfTriggers = lexical_cast<long
        // int>(m_allHeaderInfo[i].headerKeys["N_TRIGS"]);
        allHeaderInfo[i].extension =
            allHeaderInfo[i].headerKeys["XTENSION"]; // Various extensions are
                                                     // available to the FITS
                                                     // format, and must be
                                                     // parsed differently if
                                                     // this is present. Loader
                                                     // doesn't support this.

      } catch (std::exception &) {
        // todo write error and fail this load with invalid data in file.
        throw std::runtime_error("Unable to locate one or more valid BITPIX, "
                                 "NAXIS or IMAGEKEY values in the FITS file "
                                 "header.");
      }

      allHeaderInfo[i].scale =
          (allHeaderInfo[i].headerKeys[m_headerScaleKey] == "")
              ? 1
              : lexical_cast<double>(
                    allHeaderInfo[i].headerKeys[m_headerScaleKey]);
      allHeaderInfo[i].offset =
          (allHeaderInfo[i].headerKeys[m_headerOffsetKey] == "")
              ? 0
              : lexical_cast<int>(
                    allHeaderInfo[i].headerKeys[m_headerOffsetKey]);

      if (allHeaderInfo[i].extension != "")
        headerValid = false;
      if (allHeaderInfo[i].numberOfAxis != 2)
        headerValid = false;

      // Test current item has same axis values as first item.
      if (allHeaderInfo[0].axisPixelLengths[0] !=
          allHeaderInfo[i].axisPixelLengths[0])
        headerValid = false;
      if (allHeaderInfo[0].axisPixelLengths[1] !=
          allHeaderInfo[i].axisPixelLengths[1])
        headerValid = false;
    } else {
      // Unable to parse the header, throw.
      throw std::runtime_error("Unable to open the FITS file.");
    }
  }

  // Check that the files use bit depths of either 8, 16 or 32
  if (allHeaderInfo[0].bitsPerPixel != 8 &&
      allHeaderInfo[0].bitsPerPixel != 16 &&
      allHeaderInfo[0].bitsPerPixel != 32 &&
      allHeaderInfo[0].bitsPerPixel != 64)
    throw std::runtime_error(
        "FITS loader only supports 8, 16, 32 or 64 bits per pixel.");

  // Check the format is correct and create the Workspace
  if (headerValid) {
    // No extension is set, therefore it's the standard format which we can
    // parse.

    if (allHeaderInfo[0].numberOfAxis > 0)
      m_spectraCount += allHeaderInfo[0].axisPixelLengths[0];

    // Presumably 2 axis, but futureproofing.
    for (int i = 1; i < allHeaderInfo[0].numberOfAxis; ++i) {
      m_spectraCount *= allHeaderInfo[0].axisPixelLengths[i];
    }

    MantidImage imageY(allHeaderInfo[0].axisPixelLengths[0],
                       vector<double>(allHeaderInfo[0].axisPixelLengths[1]));
    MantidImage imageE(allHeaderInfo[0].axisPixelLengths[0],
                       vector<double>(allHeaderInfo[0].axisPixelLengths[1]));
    ;

    void *bufferAny = NULL;
    bufferAny = malloc((allHeaderInfo[0].bitsPerPixel / 8) * m_spectraCount);
    if (bufferAny == NULL) {
      throw std::runtime_error(
          "FITS loader couldn't allocate enough memory to run.");
    }

    // Set info in WS log to hold rotational information
    vector<double> rotations;
    if (rotFilePath != "")
      rotations = readRotations(rotFilePath, paths.size());

    // Create a group for these new workspaces, if the group already exists, add
    // to it.
    string groupName = getPropertyValue("OutputWorkspace");

    // This forms the name of the group
    m_baseName = getPropertyValue("OutputWorkspace") + "_";

    size_t fileNumberInGroup = 0;
    WorkspaceGroup_sptr wsGroup;

    if (!AnalysisDataService::Instance().doesExist(groupName)) {
      wsGroup = WorkspaceGroup_sptr(new WorkspaceGroup);
      wsGroup->setTitle(groupName);
    } else {
      // Get the name of the latest file in group to start numbering from
      if (AnalysisDataService::Instance().doesExist(groupName))
        wsGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
            groupName);

      std::string latestName = wsGroup->getNames().back();
      // Set next file number
      fileNumberInGroup = fetchNumber(latestName) + 1;
    }

    // Create a progress reporting object
    m_progress = new Progress(this, 0, 1, allHeaderInfo.size() + 1);

    // Create First workspace with instrument definition, also used as a
    // template for creating others
    Workspace2D_sptr latestWS;
    double rot = (rotations.size() > 0) ? rotations[0] : -1;
    map<size_t, Workspace2D_sptr> wsOrdered;

    latestWS = addWorkspace(allHeaderInfo[0], fileNumberInGroup, bufferAny,
                            imageY, imageE, rot, latestWS);
    wsOrdered[0] = latestWS;

    try {
      IAlgorithm_sptr loadInst = createChildAlgorithm("LoadInstrument");
      std::string directoryName =
          Kernel::ConfigService::Instance().getInstrumentDirectory();
      directoryName = directoryName + "/IMAT_Definition.xml";
      loadInst->setPropertyValue("Filename", directoryName);
      loadInst->setProperty<MatrixWorkspace_sptr>(
          "Workspace", dynamic_pointer_cast<MatrixWorkspace>(latestWS));
      loadInst->execute();
    } catch (std::exception &ex) {
      g_log.information("Cannot load the instrument definition. " +
                        string(ex.what()));
    }

    PARALLEL_FOR_NO_WSP_CHECK()
    for (int64_t i = 1; i < static_cast<int64_t>(allHeaderInfo.size()); ++i) {
      double rot =
          (static_cast<int64_t>(rotations.size()) > i) ? rotations[i] : -1;
      latestWS = addWorkspace(allHeaderInfo[i], fileNumberInGroup, bufferAny,
                              imageY, imageE, rot, latestWS);
      wsOrdered[i] = latestWS;
    }

    // Add to group - Done here to maintain order
    for (auto it = wsOrdered.begin(); it != wsOrdered.end(); ++it) {
      wsGroup->addWorkspace(it->second);
    }

    free(bufferAny);

    setProperty("OutputWorkspace", wsGroup);
  } else {
    // Invalid files, record error
    throw std::runtime_error("Loader currently doesn't support FITS files with "
                             "non-standard extensions, greater than two axis "
                             "of data, or has detected that all the files are "
                             "not similar.");
  }
}

/**
 * Initialises a workspace with IDF and fills it with data
 * @param fileInfo information for the current file
 * @param newFileNumber number for the new file when added into ws group
 * @param bufferAny Presized buffer to contain data values
 * @param imageY Object to set the Y data values in
 * @param imageE Object to set the E data values in
 * @param rotation Value for the rotation of the current file
 * @param parent A workspace which can be used to copy initialisation
 * information from (size/instrument def etc)
 * @returns A pointer to the workspace created
 */
Workspace2D_sptr LoadFITS::addWorkspace(const FITSInfo &fileInfo,
                                        size_t &newFileNumber, void *&bufferAny,
                                        MantidImage &imageY,
                                        MantidImage &imageE, double rotation,
                                        const Workspace2D_sptr parent) {
  // Create ws
  Workspace2D_sptr ws;
  if (!parent)
    ws = dynamic_pointer_cast<Workspace2D>(WorkspaceFactory::Instance().create(
        "Workspace2D", m_spectraCount, 2, 1));
  else
    ws = dynamic_pointer_cast<Workspace2D>(
        WorkspaceFactory::Instance().create(parent));

  string currNumberS = padZeros(newFileNumber, DIGIT_SIZE_APPEND);
  ++newFileNumber;

  string baseName = m_baseName + currNumberS;

  ws->setTitle(baseName);

  // set data
  readFileToWorkspace(ws, fileInfo, imageY, imageE, bufferAny);

  // Add all header info to log.
  for (auto it = fileInfo.headerKeys.begin(); it != fileInfo.headerKeys.end();
       ++it) {
    ws->mutableRun().removeLogData("_" + it->first, true);
    ws->mutableRun().addLogData(
        new PropertyWithValue<string>("_" + it->first, it->second));
  }

  // Add rotational data to log. Clear first from copied WS
  ws->mutableRun().removeLogData("Rotation", true);
  if (rotation != -1)
    ws->mutableRun().addLogData(
        new PropertyWithValue<double>("Rotation", rotation));

  // Add axis information to log. Clear first from copied WS
  ws->mutableRun().removeLogData("Axis1", true);
  ws->mutableRun().addLogData(new PropertyWithValue<int>(
      "Axis1", static_cast<int>(fileInfo.axisPixelLengths[0])));
  ws->mutableRun().removeLogData("Axis2", true);
  ws->mutableRun().addLogData(new PropertyWithValue<int>(
      "Axis2", static_cast<int>(fileInfo.axisPixelLengths[1])));

  // Add image key data to log. Clear first from copied WS
  ws->mutableRun().removeLogData("ImageKey", true);
  ws->mutableRun().addLogData(new PropertyWithValue<int>(
      "ImageKey", static_cast<int>(fileInfo.imageKey)));

  m_progress->report();

  return ws;
}

/**
 * Returns the trailing number from a string minus leading 0's (so 25 from
 * workspace_00025)the confidence with with this algorithm can load the file
 * @param name string with a numerical suffix
 * @returns A numerical representation of the string minus leading characters
 * and leading 0's
 */
size_t LoadFITS::fetchNumber(std::string name) {
  string tmpStr = "";
  for (auto it = name.end() - 1; isdigit(*it); --it) {
    tmpStr.insert(0, 1, *it);
  }
  while (tmpStr.length() > 0 && tmpStr[0] == '0') {
    tmpStr.erase(tmpStr.begin());
  }
  return (tmpStr.length() > 0) ? lexical_cast<size_t>(tmpStr) : 0;
}

// Adds 0's to the front of a number to create a string of size totalDigitCount
// including number
std::string LoadFITS::padZeros(size_t number, size_t totalDigitCount) {
  std::ostringstream ss;
  ss << std::setw(static_cast<int>(totalDigitCount)) << std::setfill('0')
     << static_cast<int>(number);

  return ss.str();
}

/**
 * Reads the data from a single FITS file into a workspace
 * @param ws Workspace to populate with the data
 * @param fileInfo information pertaining to the FITS file to load
 * @param imageY Object to set the Y data values in
 * @param imageE Object to set the E data values in
 * @param bufferAny Presized buffer to contain data values
 */
void LoadFITS::readFileToWorkspace(Workspace2D_sptr ws,
                                   const FITSInfo &fileInfo,
                                   MantidImage &imageY, MantidImage &imageE,
                                   void *&bufferAny) {
  uint8_t *buffer8 = NULL;

  // create pointer of correct data type to void pointer of the buffer:
  buffer8 = static_cast<uint8_t *>(bufferAny);

  // Read Data
  bool fileErr = false;
  FILE *currFile = fopen(fileInfo.filePath.c_str(), "rb");
  if (currFile == NULL)
    fileErr = true;

  size_t result = 0;
  if (!fileErr) {
    if (fseek(currFile, BASE_HEADER_SIZE * fileInfo.headerSizeMultiplier,
              SEEK_CUR) == 0)
      result = fread(buffer8, 1, m_spectraCount * (fileInfo.bitsPerPixel / 8),
                     currFile);
  }

  if (result != m_spectraCount * (fileInfo.bitsPerPixel / 8))
    fileErr = true;

  if (fileErr)
    throw std::runtime_error("Error reading file; possibly invalid data.");

  char *tmp = new char[fileInfo.bitsPerPixel / 8];

  for (size_t i = 0; i < fileInfo.axisPixelLengths[0]; ++i) {
    for (size_t j = 0; j < fileInfo.axisPixelLengths[1]; ++j) {
      double val = 0;
      size_t start =
          ((i * (fileInfo.bitsPerPixel / 8)) * fileInfo.axisPixelLengths[1]) +
          (j * (fileInfo.bitsPerPixel / 8));

      // Reverse byte order of current value
      std::reverse_copy(buffer8 + start,
                        buffer8 + start + (fileInfo.bitsPerPixel / 8), tmp);

      if (fileInfo.bitsPerPixel == 8)
        val = static_cast<double>(*reinterpret_cast<uint8_t *>(tmp));
      if (fileInfo.bitsPerPixel == 16)
        val = static_cast<double>(*reinterpret_cast<uint16_t *>(tmp));
      if (fileInfo.bitsPerPixel == 32 && !fileInfo.isFloat)
        val = static_cast<double>(*reinterpret_cast<uint32_t *>(tmp));
      if (fileInfo.bitsPerPixel == 64 && !fileInfo.isFloat)
        val = static_cast<double>(*reinterpret_cast<uint64_t *>(tmp));

      // cppcheck doesn't realise that these are safe casts
      // cppcheck-suppress invalidPointerCast
      if (fileInfo.bitsPerPixel == 32 && fileInfo.isFloat)
        val = static_cast<double>(*reinterpret_cast<float *>(tmp));
      // cppcheck-suppress invalidPointerCast
      if (fileInfo.bitsPerPixel == 64 && fileInfo.isFloat)
        val = *reinterpret_cast<double *>(tmp);

      val = fileInfo.scale * val - fileInfo.offset;

      imageY[i][j] = val;
      imageE[i][j] = sqrt(val);
    }
  }

  // Set in WS
  ws->setImageYAndE(imageY, imageE, 0, false);

  // Clear memory associated with the file load
  fclose(currFile);
}

/**
* Read a single files header and populate an object with the information
* @param headerInfo A FITSInfo file object to parse header information into
* @returns A bool specifying succes of the operation
*/
bool LoadFITS::parseHeader(FITSInfo &headerInfo) {
  bool ranSuccessfully = true;
  headerInfo.headerSizeMultiplier = 0;
  try {
    ifstream istr(headerInfo.filePath.c_str(), ios::binary);
    Poco::BinaryReader reader(istr);

    // Iterate 80 bytes at a time until header is parsed | 2880 bytes is the
    // fixed header length of FITS
    // 2880/80 = 36 iterations required
    bool endFound = false;
    while (!endFound) {
      headerInfo.headerSizeMultiplier++;
      for (int i = 0; i < 36; ++i) {
        // Keep vect of each header item, including comments, and also keep a
        // map of individual keys.
        string part;
        reader.readRaw(80, part);
        headerInfo.headerItems.push_back(part);

        // Add key/values - these are separated by the = symbol.
        // If it doesn't have an = it's a comment to ignore. All keys should be
        // unique
        auto eqPos = part.find('=');
        if (eqPos > 0) {
          string key = part.substr(0, eqPos);
          string value = part.substr(eqPos + 1);

          // Comments are added after the value separated by a / symbol. Remove.
          auto slashPos = value.find('/');
          if (slashPos > 0)
            value = value.substr(0, slashPos);

          boost::trim(key);
          boost::trim(value);

          if (key == "END")
            endFound = true;

          if (key != "")
            headerInfo.headerKeys[key] = value;
        }
      }
    }

    istr.close();
  } catch (...) {
    // Unable to read the file
    ranSuccessfully = false;
  }

  return ranSuccessfully;
}

/**
 * Reads a file containing rotation values for each image into a vector of
 *doubles
 * @param rotFilePath The path to a file containing rotation values
 * @param fileCount number of images which should have corresponding rotation
 *values in the file
 *
 * @returns vector<double> A vector of all the rotation values
 */
std::vector<double> LoadFITS::readRotations(std::string rotFilePath,
                                            size_t fileCount) {
  std::vector<double> allRotations;
  ifstream fStream(rotFilePath.c_str());

  try {
    // Ensure valid file
    if (fStream.good()) {
      // Get lines, split words, verify and add to map.
      string line;
      vector<string> lineSplit;
      size_t ind = -1;
      while (getline(fStream, line)) {
        ind++;
        boost::split(lineSplit, line, boost::is_any_of("\t"));

        if (ind == 0 || lineSplit[0] == "")
          continue; // Skip first iteration or where rotation value is empty

        allRotations.push_back(lexical_cast<double>(lineSplit[1]));
      }

      // Check the number of rotations in file matches number of files
      if (ind != fileCount)
        throw std::runtime_error("File error, throw higher up.");

      fStream.close();
    } else {
      throw std::runtime_error("File error, throw higher up.");
    }
  } catch (...) {
    throw std::runtime_error("Invalid file path or file format: Expected a "
                             "file with a line separated list of rotations "
                             "with the same number of entries as other files.");
  }

  return allRotations;
}

/**
 *  Maps the header keys to specified values
 */
void LoadFITS::mapHeaderKeys() {
  bool useProperties = true;

  // If a map file is selected, use that.
  if (getPropertyValue(HEADER_MAP_NAME) != "") {
    // std::vector<double> allRotations;
    ifstream fStream(getPropertyValue(HEADER_MAP_NAME).c_str());

    try {
      // Ensure valid file
      if (fStream.good()) {
        // Get lines, split words, verify and add to map.
        string line;
        vector<string> lineSplit;
        while (getline(fStream, line)) {
          boost::split(lineSplit, line, boost::is_any_of("="));

          if (lineSplit[0] == ROTATION_NAME && lineSplit[1] != "")
            m_headerRotationKey = lineSplit[1];

          if (lineSplit[0] == BIT_DEPTH_NAME && lineSplit[1] != "")
            m_headerBitDepthKey = lineSplit[1];

          if (lineSplit[0] == AXIS_NAMES_NAME && lineSplit[1] != "") {
            m_headerAxisNameKeys.clear();
            std::string propVal = getProperty(AXIS_NAMES_NAME);
            boost::split(m_headerAxisNameKeys, propVal, boost::is_any_of(","));
          }

          if (lineSplit[0] == IMAGE_KEY_NAME && lineSplit[1] != "") {
            m_headerImageKeyKey = lineSplit[1];
          }
        }

        fStream.close();
        useProperties = false;
      } else {
        throw std::runtime_error("File error, throw higher up.");
      }
    } catch (...) {
      g_log.information("Cannot load specified map file, using property values "
                        "and/or defaults.");
      useProperties = true;
    }
  }

  if (useProperties) {
    // Try and set from the loader properties if present and didn't load map
    // file
    if (getPropertyValue(BIT_DEPTH_NAME) != "")
      m_headerBitDepthKey = getPropertyValue(BIT_DEPTH_NAME);
    if (getPropertyValue(ROTATION_NAME) != "")
      m_headerRotationKey = getPropertyValue(ROTATION_NAME);
    if (getPropertyValue(AXIS_NAMES_NAME) != "") {
      m_headerAxisNameKeys.clear();
      std::string propVal = getProperty(AXIS_NAMES_NAME);
      boost::split(m_headerAxisNameKeys, propVal, boost::is_any_of(","));
    }
    if (getPropertyValue(IMAGE_KEY_NAME) != "")
      m_headerImageKeyKey = getPropertyValue(IMAGE_KEY_NAME);
  }
}
}
}