mlReleaseToolsMisc.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#pragma once
 
// Local includes
#include "MLReleaseToolsSystem.h"
 
// For StringVector.
#include "mlDirectoryMatching.h"
 
// ML includes
#include <mlModuleIncludes.h>
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
namespace ReleaseToolsMisc {

MLRELEASE_TOOLS_EXPORT  extern const std::string LineSeparator;

MLRELEASE_TOOLS_EXPORT  ReleaseToolsIO::StringVector split(const std::string &value, 
                                                           const std::string &sep = LineSeparator);

MLRELEASE_TOOLS_EXPORT  ReleaseToolsIO::StringVector filterWithRegExVector(const ReleaseToolsIO::StringVector &strVec,
                                                                           const ReleaseToolsIO::StringVector &regExpressionsVec,
                                                                           std::vector<size_t>                *matchedRegExIdxVec=nullptr);

MLRELEASE_TOOLS_EXPORT  ReleaseToolsIO::StringVector filterWithRegExVector(const ReleaseToolsIO::StringVector &strVec,
                                                                           const std::string                  &regEx);

MLRELEASE_TOOLS_EXPORT  std::string filterLinesWithRegEx(const std::string &str,
                                                         const std::string &regEx,
                                                         const std::string &sep=LineSeparator);

MLRELEASE_TOOLS_EXPORT  ReleaseToolsIO::StringVector filterLines(const ReleaseToolsIO::StringVector &inLines,
                                                                 const bool                         useRegularExpression,
                                                                 const std::string                  &firstExpression,
                                                                 const std::string                  &lineEnd,
                                                                 const MLint                        index,
                                                                 std::string                        *errorInfos=nullptr);

MLRELEASE_TOOLS_EXPORT  MLErrorCode copyBitSubImagesToUInt8SubImage(SubImage                    &outSubImage ,
                                                                    const std::vector<SubImage> &frameSubImgs, 
                                                                    MLint                       zTranslate   = 0,
                                                                    MLuint8                     value        = 1,
                                                                    bool                        orValue      = false);

MLRELEASE_TOOLS_EXPORT bool isEquidistant(const std::vector<double> &dblVec, double eps=10e-5);

enum MonotonicTypes {
  Empty                       =   1, 
  Singular                    =   2, 
  Irregular                   =   4, 
  Uniform                     =   8, 
  StrictlyMonotonicDecreasing =  16, 
  MonotonicDecreasing         =  32, 
  MonotonicIncreasing         =  64, 
  StrictlyMonotonicIncreasing = 128  
};

MLRELEASE_TOOLS_EXPORT int getMonotonicProperties(const std::vector<double> &dblVec, double eps=10e-5);

MLRELEASE_TOOLS_EXPORT MLErrorCode calculateAverageOfSumOfSquaredDifferences(const SubImage &subImg1,
                                                                             const SubImage &subImg2,
                                                                             double         &avrOfSumOfSquaredDiffs);
 

template <typename DT1, typename DT2>
  inline double calculateAverageOfSumOfSquaredDifferences(TSubImage<DT1> &img1,
                                                          TSubImage<DT2> &img2,
                                                          SubImageBox    box)
  {
    double avrOfSumOfSquaredDifferences = -1.;
    box = box.intersect(img1.getBox().intersect(img2.getBox()));
    if (!box.isEmpty()){
      avrOfSumOfSquaredDifferences = 0.;
      ImageVector p;
      for (p.u = box.v1.u; p.u <= box.v2.u; ++p.u){
        for (p.t = box.v1.t; p.t <= box.v2.t; ++p.t){
          for (p.c = box.v1.c; p.c <= box.v2.c; ++p.c){
            for (p.z = box.v1.z; p.z <= box.v2.z; ++p.z){
              for (p.y = box.v1.y; p.y <= box.v2.y; ++p.y){
                // Get pointers to row starts.
                p.x = box.v1.x;
                const DT1 *v1 = img1.getImagePointer(p);
                const DT2 *v2 = img2.getImagePointer(p);
                for (; p.x <= box.v2.x; ++p.x, ++v1, ++v2){
                  // Determine difference between both voxels and sum up squares.
                  const double diff = static_cast<double>(*v1) - static_cast<double>(*v2);
                  avrOfSumOfSquaredDifferences += diff*diff;
                }
              }
            }
          }
        }
      }
      // Calculate the average of all of sum of squared differences. 
      avrOfSumOfSquaredDifferences /= static_cast<double>(box.getNumVoxels());
    }
    return avrOfSumOfSquaredDifferences;
  }

MLRELEASE_TOOLS_EXPORT std::string toBase64(const std::string &inString);

MLRELEASE_TOOLS_EXPORT std::string fromBase64(const std::string &inString);

MLRELEASE_TOOLS_EXPORT std::string createHashFromBytes(const unsigned char *data, size_t numBytes, const std::string &hashAlgorithm="SHA1");
 
};
 
ML_END_NAMESPACE