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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// Copyright (c) 2016, 2017 GeometryFactory
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL: https://github.com/CGAL/cgal/blob/v6.1.1/CGAL_ImageIO/include/CGAL/SEP_to_ImageIO.h $
// $Id: include/CGAL/SEP_to_ImageIO.h 08b27d3db14 $
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
// Author(s) : Laurent Rineau
#ifndef CGAL_SEP_READER_IMAGEIO_HPP
#define CGAL_SEP_READER_IMAGEIO_HPP
#include "SEP_header.h"
#include <CGAL/ImageIO.h>
#include <CGAL/Image_3.h>
#include <fstream>
#include <algorithm>
#include <string>
#include <filesystem>
#include <CGAL/IO/binary_file_io.h>
namespace CGAL {
template <typename T>
class SEP_to_ImageIO : public SEP_header
{
T* _data;
_image* _im;
CGAL::Image_3* _cgal_image;
bool valid;
std::string err_msg;
public:
bool is_valid() const { return valid; }
std::string error_msg() const { return err_msg; }
SEP_to_ImageIO(std::string fileName)
: SEP_header(fileName),
_data(0),
_im(0), _cgal_image(0),
valid(false), err_msg()
{
if(dimension() < 0) {
err_msg = "Invalid header file \"";
err_msg += fileName;
err_msg += "\"";
return;
}
display_information(fileName, std::cout);
std::filesystem::path headerFile(fileName);
std::filesystem::path dataFile = std::filesystem::absolute(fileName).parent_path() / std::filesystem::path(string_field("in"));
if(!load_data(dataFile.string())) {
return;
err_msg = "Invalid data file \"";
err_msg += dataFile.string();
err_msg += "\"";
}
valid = true;
}
~SEP_to_ImageIO()
{
if(_cgal_image != 0) delete _cgal_image;
}
CGAL::Image_3* cgal_image() { return _cgal_image; }
const CGAL::Image_3* cgal_image() const { return _cgal_image; }
protected :
bool load_data(std::string dataFilename)
{
if(_im) delete _im;
_im = new _image;
_im->xdim = static_cast<unsigned int>(n(1));
_im->ydim = static_cast<unsigned int>(n(2));
_im->zdim = static_cast<unsigned int>(n(3));
_im->vdim = 1;
// spacing
_im->vx = d(1);
_im->vy = d(2);
_im->vz = d(3);
if(_im->vz == 0.f) _im->vz=1.f;
// image offset
_im->tx = static_cast<float>(o(1));
_im->ty = static_cast<float>(o(2));
_im->tz = static_cast<float>(o(3));
// image center
_im->cx = _im->cy = _im->cz = 0;
// image rotation
_im->rx = _im->ry = _im->rz = 0.0;
_im->fd = nullptr;
_im->openMode = OM_CLOSE;
if(string_field("data_format") == "native_float" ||
string_field("data_format") == "\"native_float\"")
{
_im->endianness = END_LITTLE;
} else {
_im->endianness = END_BIG;
}
_im->dataMode = DM_BINARY;
// no user string
_im->user = nullptr;
_im->nuser = 0;
// word type (unsigned byte)
_im->wdim = sizeof(T);
_im->wordKind = WK_FLOAT;
_im->vectMode = VM_SCALAR;
_im->sign = SGN_SIGNED;
_im->imageFormat = nullptr;
::_openReadImage(_im, dataFilename.c_str());
if(!_im->fd) return false;
// Compute number of element
const std::size_t size = n(1) * n(2) * n(3);
// Allocate array
_data = new T[size];
_im->data = (void*)_data;
// // Read file
if(_readImageData(_im) < 0) return false;
// char* buffer = reinterpret_cast<char*>(_data);
// in.read (buffer, size * sizeof(T));
ImageIO_close(_im);
_cgal_image = new CGAL::Image_3(_im);
return true;
}
};
} // end namespace CGAL
#endif // CGAL_SEP_READER_IMAGEIO_HPP
|
