MSNumpressCoder.h

Go to the documentation of this file.

// Copyright (c) 2002-2023, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Hannes Roest $
// $Authors: Hannes Roest $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/DATASTRUCTURES/String.h>
 
#include <algorithm>
#include <string>
#include <vector>
 
namespace OpenMS
{
  const double BinaryDataEncoder_default_numpressErrorTolerance = .0001; // 1/100th of one percent
 
  class OPENMS_DLLAPI MSNumpressCoder
  {
 
public:
 
    enum NumpressCompression {
      NONE, 
      LINEAR, 
      PIC, 
      SLOF, 
      SIZE_OF_NUMPRESSCOMPRESSION
    };
    static const std::string NamesOfNumpressCompression[SIZE_OF_NUMPRESSCOMPRESSION];
 
    struct OPENMS_DLLAPI NumpressConfig
    {
      double numpressFixedPoint;
      double numpressErrorTolerance;
      NumpressCompression np_compression;
      bool estimate_fixed_point;
      double linear_fp_mass_acc;
 
      NumpressConfig () :
        numpressFixedPoint(0.0),
        numpressErrorTolerance(BinaryDataEncoder_default_numpressErrorTolerance),
        np_compression(NONE),
        estimate_fixed_point(true),
        linear_fp_mass_acc(-1)
      {
      }
 
      void setCompression(const std::string& compression)
      {
        const std::string* match = std::find(NamesOfNumpressCompression,
                                             NamesOfNumpressCompression + SIZE_OF_NUMPRESSCOMPRESSION, compression);
 
        if (match == NamesOfNumpressCompression + SIZE_OF_NUMPRESSCOMPRESSION) // == end()
        {
          throw Exception::InvalidParameter(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
                                            "Value '" + compression + "' is not a valid Numpress compression scheme.");
        }
 
        np_compression = (NumpressCompression)std::distance(NamesOfNumpressCompression, match);
      }
 
    };
 
    MSNumpressCoder() {}
 
    virtual ~MSNumpressCoder() {}
 
    void encodeNP(const std::vector<double> & in,
                  String & result,
                  bool zlib_compression,
                  const NumpressConfig & config);
 
    void encodeNP(const std::vector<float> & in,
                  String & result,
                  bool zlib_compression,
                  const NumpressConfig & config);
 
    void decodeNP(const String & in,
                  std::vector<double> & out,
                  bool zlib_compression,
                  const NumpressConfig & config);
 
    void encodeNPRaw(const std::vector<double> & in,
                     String & result,
                     const NumpressConfig & config);
 
    void decodeNPRaw(const std::string & in,
                     std::vector<double> & out,
                     const NumpressConfig & config);
 
private:
 
    void decodeNPInternal_(const unsigned char* in, size_t in_size, std::vector<double>& out, const NumpressConfig & config);
  };
 
} //namespace OpenMS