ImzMLHandler.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Aditya Sarna $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/FORMAT/HANDLERS/MzMLHandler.h>
#include <OpenMS/FORMAT/OPTIONS/PeakFileOptions.h>
#include <OpenMS/FORMAT/HANDLERS/ImzMLHandlerHelper.h>
 
#include <OpenMS/INTERFACES/IMSDataConsumer.h>
 
#include <cstdio>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace OpenMS
{
namespace Internal
{
 
  class ImzMLInterceptConsumer; // defined in ImzMLHandler.cpp
 
  class OPENMS_DLLAPI ImzMLHandler final : public MzMLHandler
  {
    friend class ImzMLInterceptConsumer;
 
  public:
 
    ImzMLHandler(PeakMap&              exp,
                 const std::string&    filename,
                 const ProgressLogger& logger);
 
    ~ImzMLHandler() override;  
 
    ImzMLHandler(const ImzMLHandler&)            = delete;
    ImzMLHandler& operator=(const ImzMLHandler&) = delete;
 
    void openIBD(const std::string& ibd_path);
 
    const ImzMLMeta& getImzMLMeta() const noexcept { return meta_; }
 
    ImzMLMeta&       getImzMLMeta()       noexcept { return meta_; }
 
    bool hasPixelSizeY() const noexcept { return pixel_size_y_given_; }
 
    const std::vector<ImzMLSpectrumIndex>& getIndex() const noexcept { return index_; }
 
    void connectDecodeConsumer(Interfaces::IMSDataConsumer* downstream,
                               bool append_spectra_to_map,
                               bool decode_ibd = true);
 
    // ------------------------------------------------------------------
    // XML event callbacks (MzMLHandler is called through for MS:* terms)
    // ------------------------------------------------------------------
 
    void onStartElement(const char16_t* qname, const XMLAttributes& attrs) override;
 
    void onEndElement(const char16_t* qname) override;
 
  private:
 
    // ------------------------------------------------------------------
    // IMS CV dispatch
    // ------------------------------------------------------------------
    void handleIMSCvParam_(const std::string& acc, const std::string& name, const std::string& val,
                           const std::string& unit_accession = "");
    void applyRefGroup_   (const std::string& id);
 
    // ------------------------------------------------------------------
    // Per-binaryDataArray IMS metadata
    // ------------------------------------------------------------------
    struct ArrayMeta
    {
      ImzMLSpectrumIndex::DataType dt      { ImzMLSpectrumIndex::DataType::UNKNOWN };
      bool     is_mz  { false };
      bool     is_int { false };
      bool     is_ext { false };  
      uint64_t offset { 0 };     
      uint64_t count  { 0 };     
      uint64_t encoded_bytes { 0 }; 
      bool     compressed { false };
      std::string accession;
      std::string name;
      std::string unit_accession;
 
      void reset() noexcept { *this = ArrayMeta{}; }
    };
 
    // ------------------------------------------------------------------
    // Per-spectrum IMS state snapshot (stored at endElement("spectrum"))
    // ------------------------------------------------------------------
    struct SpecIMS
    {
      uint32_t  x {0}, y {0}, z {1};
      ArrayMeta mz_meta;
      ArrayMeta int_meta;
      std::vector<ArrayMeta> aux_meta;
      std::vector<std::string> inline_aux_names;
      bool has_scan_start_time {false};
    };
 
    // ------------------------------------------------------------------
    // State
    // ------------------------------------------------------------------
    FILE*      ibd_          { nullptr };
    ImzMLMeta  meta_;
 
    bool       in_spectrum_  { false };
    bool       in_scan_      { false };
    bool       in_bda_       { false };
    uint32_t   cur_x_        { 0 };
    uint32_t   cur_y_        { 0 };
    uint32_t   cur_z_        { 1 };
    ArrayMeta  cur_array_;
    ArrayMeta  cur_mz_meta_;
    ArrayMeta  cur_int_meta_;
    std::vector<ArrayMeta> cur_aux_metas_;
    std::vector<std::string> cur_inline_aux_names_;
 
    std::vector<SpecIMS>             spec_ims_;  
    std::vector<ImzMLSpectrumIndex>  index_;     
 
    struct CvEntry
    {
      std::string accession;
      std::string name;
      std::string value;
      std::string unit_accession;
    };
    std::unordered_map<std::string, std::vector<CvEntry>> ref_groups_;
    std::string cur_ref_id_;
    bool   in_ref_group_ { false };
    bool   decode_ibd_ { true };
    bool   cur_x_seen_ { false };
    bool   cur_y_seen_ { false };
    bool   pixel_size_y_given_ { false };
 
    std::unique_ptr<ImzMLInterceptConsumer> decode_bridge_;
  };
 
} // namespace Internal
} // namespace OpenMS