EerReaderLib/EerFile.cpp at master · aseedb/EerReaderLib · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
// Copyright (c) 2019 by FEI Company

#include "EerFile.h"
#include <iostream>

namespace Fei {
namespace Acquisition {
namespace EerReader {

namespace
{
    const uint16_t TIFF_COMPRESSION_EER_V0 = 65000;
    const uint16_t TIFF_COMPRESSION_EER_V1 = 65001;
    const uint16_t TIFF_COMPRESSION_EER_V2 = 65002;

    const uint16_t TIFFTAG_EER_ACQUISITION_METADATA = 65001;
    const uint16_t TIFFTAG_EER_FINAL_IMAGE_METADATA = 65006;
    const uint16_t TIFFTAG_EER_FINAL_IMAGE_PROCESSING_METADATA = 65005;
    const uint16_t TIFFTAG_EER_FRAME_METADATA = 65002;
    const uint16_t TIFFTAG_EER_FRAME_PROCESSING_METADATA = 65004;
    const uint16_t EER_DECODER_SKIPBITS = 65007;
    const uint16_t EER_DECODER_HORZBITS = 65008;
    const uint16_t EER_DECODER_VERTBITS = 65009;

    void MyTIFFOutputError(const char* module, const char* fmt, va_list ap)
    {
        std::cout << module << ": ";
        vprintf(fmt, ap);
        std::cout << std::endl;
    }


    std::string GetFieldAsString(TIFF* tiff, ttag_t tag)
    {
        char* data = nullptr;
        uint32_t count = 0;
        if (TIFFGetField(tiff, tag, &count, &data) != 1) throw std::runtime_error("GetField: Field with tag " + std::to_string(tag) + " is not present.");
        return std::string(data, count);
    }

    void TagExtender(TIFF *tif)
    {
        static const TIFFFieldInfo fieldInfo[] =
        {
            { TIFFTAG_EER_ACQUISITION_METADATA, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_UNDEFINED, FIELD_CUSTOM, true, true, "Acquisition metadata" },
            { TIFFTAG_EER_FINAL_IMAGE_METADATA, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_UNDEFINED, FIELD_CUSTOM, true, true, "Final image metadata" },
            { TIFFTAG_EER_FINAL_IMAGE_PROCESSING_METADATA, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_UNDEFINED, FIELD_CUSTOM, true, true, "Final image processing metadata" },
            { TIFFTAG_EER_FRAME_METADATA, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_UNDEFINED, FIELD_CUSTOM, true, true, "Frame metadata" },
            { TIFFTAG_EER_FRAME_PROCESSING_METADATA, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_UNDEFINED, FIELD_CUSTOM, true, true, "Frame processing metadata" },
            { EER_DECODER_SKIPBITS, 1, 1, TIFF_SHORT, FIELD_CUSTOM, false, false, "SKIPBITS" },
            { EER_DECODER_HORZBITS, 1, 1, TIFF_SHORT, FIELD_CUSTOM, false, false, "HORZBITS" },
            { EER_DECODER_VERTBITS, 1, 1, TIFF_SHORT, FIELD_CUSTOM, false, false, "VERTBITS" }
        };

     TIFFMergeFieldInfo(tif, fieldInfo, sizeof(fieldInfo) / sizeof(fieldInfo[0]));
}
}

EerFile::EerFile(const std::string & filename)
{
    TIFFSetErrorHandler(MyTIFFOutputError);
    TIFFSetWarningHandler(MyTIFFOutputError);
    TIFFSetTagExtender(TagExtender);

    m_tiff = std::shared_ptr<TIFF>(TIFFOpen(filename.c_str(), "rl"), [](TIFF* tiffPtr){ if (tiffPtr) TIFFClose(tiffPtr); });
    if (!m_tiff)
        throw std::runtime_error("unable to open tiff file");

    if (!IsCurrentFrameEERCompressed())
    {
        m_finalImageBitmap = std::make_shared<Bitmap>(m_tiff.get());
    }
    else
    {
        m_finalImageBitmap = nullptr;
    }
}

EerFile::~EerFile()
{
}

std::unique_ptr<EerFrame> EerFile::GetNextEerFrame()
{
    std::unique_ptr<EerFrame> eerFrame;
    while (m_nextFrameAvailable && !eerFrame)
    {
        if (IsCurrentFrameEERCompressed())
            eerFrame = std::make_unique<EerFrame>(m_tiff.get());
        m_nextFrameAvailable = (TIFFReadDirectory(m_tiff.get()) == 1);
    }

    return std::move(eerFrame);
}

std::shared_ptr<Bitmap> EerFile::GetFinalImage()
{
    return m_finalImageBitmap;
}

std::string EerFile::GetAcquisitionMetadata() const
{
    return GetFieldAsString(m_tiff.get(), TIFFTAG_EER_ACQUISITION_METADATA);
}

bool EerFile::IsCurrentFrameEERCompressed()
{
    uint16_t compression;
    TIFFGetField(m_tiff.get(), TIFFTAG_COMPRESSION, &compression);
    return compression == TIFF_COMPRESSION_EER_V0 || compression == TIFF_COMPRESSION_EER_V1 || compression == TIFF_COMPRESSION_EER_V2;
}

} //namespace EerReader
} //namespace Acquisition
} //namespace Fei