← Back to branch summary

~ubuntu-branches/ubuntu/lucid/meshlab/lucid

« back to all changes in this revision

Viewing changes to vcglib/wrap/qt/img_qt_io.h

  • Committer: Bazaar Package Importer
  • Author(s): Teemu Ikonen
  • Date: 2009-10-08 16:40:41 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20091008164041-0c2ealqv8b8uc20c
Tags: 1.2.2-1
http://bugs.debian.org/539544
* New upstream version
* Do not build filter_isoparametrization because liblevmar dependency
  is not (yet) in Debian
* Fix compilation with gcc-4.4, thanks to Jonathan Liu for the patch
  (closes: #539544)
* rules: Add compiler variables to the qmake call (for testing with new
  GCC versions)
* io_3ds.pro: Make LIBS and INCLUDEPATH point to Debian version of lib3ds
* io_epoch.pro: Make LIBS point to Debian version of libbz2
* control:
  - Move Homepage URL to the source package section
  - Update to standards-version 3.8.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
vcglib/wrap/qt/img_qt_io.h
 
1
#ifndef IMG_QT_IO_H_
 
2
#define IMG_QT_IO_H_
 
3
 
 
4
#include <fstream>
 
5
// input/output using the qt system
 
6
 
 
7
#include <QImage>
 
8
 
 
9
#include "wrap/qt/img_qt_convert.h"
 
10
#include "img/img_io.h"
 
11
 
 
12
namespace img {
 
13
 
 
14
template<typename ScalarType, bool Safe> 
 
15
inline void openQtY(const QString filename, Image<1,ScalarType,Safe> &image)
 
16
{
 
17
   convert_QImage_to_Y(QImage(filename),image);
 
18
}
 
19
 
 
20
template<typename ScalarType, bool Safe> 
 
21
inline void openQtRGB(const QString filename, Image<3,ScalarType,Safe> &image)
 
22
{
 
23
   convert_QImage_to_RGB(QImage(filename),image);
 
24
}
 
25
 
 
26
//// queste le tengo commentate perche` ora non mi servono
 
27
//template<typename ScalarType, bool Safe> 
 
28
//inline void openQtRGBA(const QString filename, Image<4,ScalarType,Safe> &image)
 
29
//{
 
30
//   convert_QImage_to_RGBA(QImage(filename),image);
 
31
//}
 
32
//
 
33
//template<typename ScalarType, bool Safe> 
 
34
//inline void openQtY(const char *filename, Image<1,ScalarType,Safe> &image)
 
35
//{
 
36
//  openQtY(QString(filename),image);
 
37
//}
 
38
//
 
39
//template<typename ScalarType, bool Safe> 
 
40
//inline void openQtRGB(const char *filename, Image<3,ScalarType,Safe> &image)
 
41
//{
 
42
//  openQtRGB(QString(filename),image);
 
43
//}
 
44
//
 
45
//template<typename ScalarType, bool Safe> 
 
46
//inline void openQtRGBA(const char *filename, Image<4,ScalarType,Safe> &image)
 
47
//{
 
48
//  openQtRGBA(QString(filename),image);
 
49
//}
 
50
//
 
51
template<typename ScalarType, bool Safe> 
 
52
inline bool saveQtY(const Image<1,ScalarType,Safe> &image,const QString filename)
 
53
{
 
54
  QImage qimage;
 
55
  convert_Y_to_QImage(image,qimage);
 
56
  bool success = qimage.save(filename);
 
57
  assert(success);
 
58
  if(Safe){
 
59
    if(!success)  throw ImageException("cannot save image");
 
60
  }
 
61
  return success;
 
62
}
 
63
 
 
64
template<typename ScalarType, bool Safe> 
 
65
inline bool saveQtRGB(const Image<3,ScalarType,Safe> &image,const QString filename)
 
66
{
 
67
  QImage qimage;
 
68
  convert_RGB_to_QImage(image,qimage);
 
69
  bool success = qimage.save(filename);
 
70
  assert(success);
 
71
  if(Safe){
 
72
    if(!success)  throw ImageException("cannot save image");
 
73
  }
 
74
  return success;
 
75
}
 
76
 
 
77
//// queste le tengo commentate perche` ora non mi servono
 
78
//template<typename ScalarType, bool Safe> 
 
79
//inline bool saveQtRGBA(const Image<4,ScalarType,Safe> &image,const QString filename)
 
80
//{
 
81
//  QImage qimage;
 
82
//  convert_RGBA_to_QImage(image,qimage);
 
83
//  bool success = qimage.save(filename);
 
84
//  assert(success);
 
85
//  if(Safe){
 
86
//    if(!success)  throw ImageException("cannot save image");
 
87
//  }
 
88
//  return success;
 
89
//}
 
90
//
 
91
//template<typename ScalarType, bool Safe>
 
92
//inline bool saveQtY(const Image<1,ScalarType,Safe> &image,const char *filename)
 
93
//{
 
94
//  return saveQtY(image,QString(filename));
 
95
//}
 
96
//
 
97
//template<typename ScalarType, bool Safe>
 
98
//inline bool saveQtRGB(const Image<3,ScalarType,Safe> &image,const char *filename)
 
99
//{
 
100
//  return saveQtRGB(image,QString(filename));
 
101
//}
 
102
//
 
103
//template<typename ScalarType, bool Safe>
 
104
//inline bool saveQtRGBA(const Image<4,ScalarType,Safe> &image,const char *filename)
 
105
//{
 
106
//  return saveQtRGBA(image,QString(filename));
 
107
//}
 
108
 
 
109
template<typename ScalarType, bool Safe>
 
110
inline bool savePGM(const Image<1,ScalarType,Safe> &image, const QString filename)
 
111
{
 
112
  assert(image.isValid());
 
113
  assert(image.attributes.hasRange(ScalarType(0.0),ScalarType(255.0)));
 
114
  assert(filename.endsWith(".pgm",Qt::CaseInsensitive));
 
115
  if(Safe){
 
116
    if(!image.isValid()) throw ImageException("Invalid image");
 
117
    if(!image.attributes.hasRange(ScalarType(0.0),ScalarType(255.0))) throw ImageException("Invalid range attribute");
 
118
    if(!filename.endsWith(".pgm",Qt::CaseInsensitive)) throw ImageException("filename is not .pgm");
 
119
  }
 
120
  using namespace std;
 
121
  ofstream file (filename.toStdString().c_str(), ios::out|ios::binary|ios::trunc);
 
122
  if (file.is_open()) {
 
123
    QString header = QString("P5 %1 %2 255\n").arg(image.width()).arg(image.height());
 
124
    file << header.toStdString().c_str();
 
125
 
 
126
  for (int y_coord = 0; y_coord < image.height(); ++y_coord)
 
127
    for (int x_coord = 0; x_coord < image.width(); ++x_coord){
 
128
      unsigned char v = static_cast<unsigned char>(valueAsInt(clampValue(image.getValue(x_coord,y_coord,0))));  
 
129
      file << v;
 
130
    }
 
131
 
 
132
    file.close();
 
133
    return true;
 
134
  }
 
135
  if(Safe)
 
136
    throw ImageException("Unable to open file");
 
137
  return false;
 
138
}
 
139
 
 
140
// range and gamma aware I/O
 
141
 
 
142
template<typename ScalarType, bool Safe> 
 
143
inline void open_and_normalize_range_Y(const QString filename, Image<1,ScalarType,Safe> &range_0_1_image)
 
144
{
 
145
  Image<1,ScalarType,Safe> range_0_255_image;
 
146
  openQtY(filename,range_0_255_image);
 
147
  convert_range_0_255_to_0_1(range_0_255_image,range_0_1_image);
 
148
}
 
149
 
 
150
template<typename ScalarType, bool Safe> 
 
151
inline void open_and_normalize_range_RGB(const QString filename, Image<3,ScalarType,Safe> &range_0_1_image)
 
152
{
 
153
  Image<3,ScalarType,Safe> range_0_255_image;
 
154
  openQtRGB(filename,range_0_255_image);
 
155
  convert_range_0_255_to_0_1(range_0_255_image,range_0_1_image);
 
156
}
 
157
 
 
158
template<typename ScalarType, bool Safe> 
 
159
inline void open_normalize_range_and_SRGB_linearize_RGB(const QString filename, Image<3,ScalarType,Safe> &linear_image)
 
160
{
 
161
  Image<3,ScalarType,Safe> range_0_1_image;
 
162
  open_and_normalize_range_RGB(filename, range_0_1_image);
 
163
  range_0_1_image.attributes.setColorspace(img::SRGB); // assumes sRGB colorspace for gamma compression
 
164
  convert_gamma_precompensated_srgb_to_linear_srgb(range_0_1_image,linear_image);
 
165
}
 
166
 
 
167
template<typename ScalarType, bool Safe>
 
168
inline bool adjust_range_and_save_PGM(const Image<1,ScalarType,Safe> &range_0_1_image, const QString filename)
 
169
{
 
170
  Image<1,ScalarType,Safe> range_0_255_image;
 
171
  convert_range_0_1_to_0_255(range_0_1_image,range_0_255_image);
 
172
  return savePGM(range_0_255_image,filename);
 
173
}
 
174
 
 
175
template<typename ScalarType, bool Safe>
 
176
inline bool SRGB_compress_adjust_range_and_save_PGM(const Image<1,ScalarType,Safe> &linear_image, const QString filename)
 
177
{
 
178
  Image<1,ScalarType,Safe> range_0_1_image;
 
179
  convert_linear_srgb_to_gamma_precompensated_srgb(linear_image,range_0_1_image);
 
180
  return adjust_range_and_save_PGM(range_0_1_image,filename);
 
181
}
 
182
 
 
183
template<typename ScalarType, bool Safe>
 
184
inline bool adjust_range_and_save_RGB(const Image<3,ScalarType,Safe> &range_0_1_image, const QString filename)
 
185
{
 
186
  Image<3,ScalarType,Safe> range_0_255_image;
 
187
  convert_range_0_1_to_0_255(range_0_1_image,range_0_255_image);
 
188
  return saveQtRGB(range_0_255_image,filename);
 
189
}
 
190
 
 
191
template<typename ScalarType, bool Safe>
 
192
inline bool SRGB_compress_adjust_range_and_save_RGB(const Image<3,ScalarType,Safe> &linear_image,const QString filename)
 
193
{
 
194
  Image<3,ScalarType,Safe> range_0_1_image;
 
195
  convert_linear_srgb_to_gamma_precompensated_srgb(linear_image,range_0_1_image);
 
196
  return adjust_range_and_save_RGB(range_0_1_image,filename);
 
197
}
 
198
 
 
199
template<typename ScalarType, bool Safe>
 
200
inline bool adjust_range_and_save_Y(const Image<1,ScalarType,Safe> &range_0_1_image, const QString filename)
 
201
{
 
202
  Image<1,ScalarType,Safe> range_0_255_image;
 
203
  convert_range_0_1_to_0_255(range_0_1_image,range_0_255_image);
 
204
  return saveQtY(range_0_255_image,filename);
 
205
}
 
206
 
 
207
template<typename ScalarType, bool Safe>
 
208
inline bool SRGB_compress_adjust_range_and_save_Y(const Image<1,ScalarType,Safe> &linear_image,const QString filename)
 
209
{
 
210
  Image<1,ScalarType,Safe> range_0_1_image;
 
211
  convert_linear_srgb_to_gamma_precompensated_srgb(linear_image,range_0_1_image);
 
212
  return adjust_range_and_save_Y(range_0_1_image,filename);
 
213
}
 
214
 
 
215
//// queste le tengo commentate perche` ora non mi servono
 
216
//template<typename ScalarType, bool Safe> 
 
217
//inline void open_normalize_range_and_SRGB_linearize_Y(const QString filename, Image<1,ScalarType,Safe> &linear_image)
 
218
//{
 
219
//  Image<1,ScalarType,Safe> range_0_255_image, range_0_1_image;
 
220
//  openQtY(filename,range_0_255_image);
 
221
//  range_0_255_image.attributes.setColorspace(img::SRGB); // assumes sRGB colorspace (for gamma compression)
 
222
//  convert_range_0_255_to_0_1(range_0_255_image,range_0_1_image);
 
223
//  convert_gamma_precompensated_srgb_to_linear_srgb(range_0_1_image,linear_image);
 
224
//}
 
225
//
 
226
//template<typename ScalarType, bool Safe>
 
227
//inline bool SRGB_compress_adjust_range_and_save_Y(const Image<1,ScalarType,Safe> &linear_image,const QString filename)
 
228
//{
 
229
//  Image<1,ScalarType,Safe> range_0_1_image, range_0_255_image;
 
230
//  convert_linear_srgb_to_gamma_precompensated_srgb(linear_image,range_0_1_image);
 
231
//  convert_range_0_1_to_0_255(range_0_1_image,range_0_255_image);
 
232
//  return aveQtY(range_0_255_image,filename);
 
233
//}
 
234
//
 
235
 
 
236
///// queste chi gli serve se le riimplementa, ora non c'ho tempo
 
237
//template <class PIXELTYPE, bool SAFE> 
 
238
//inline void dumpNormalized(const Image<PIXELTYPE,SAFE> &image,const QString filename)
 
239
//{
 
240
//  save(image::getNormalized(image),filename);
 
241
//}
 
242
//
 
243
//template <class PIXELTYPE, bool SAFE> 
 
244
//inline void dumpNormalized(const Image<PIXELTYPE,SAFE> &image,const char *filename)
 
245
//{
 
246
//  saveNormalized(image,QString(filename));
 
247
//}
 
248
//
 
249
//template <class PIXELTYPE, bool SAFE> 
 
250
//inline void dumpAsRaw(const Image<PIXELTYPE,SAFE> &image,const QString filename)
 
251
//{
 
252
//  dumpAsRaw(image,filename.toStdString().c_str());
 
253
//}
 
254
//
 
255
//template <class PIXELTYPE, bool SAFE> 
 
256
//inline void dumpAsAscii(const Image<PIXELTYPE,SAFE> &image,const QString filename)
 
257
//{
 
258
//  dumpAsAscii(image,filename.toStdString().c_str());
 
259
//}
 
260
//
 
261
 
 
262
} //end namespace img
 
263
 
 
264
#endif /*IMG_QT_IO_H_*/