brainrat-private 6.0.4
channelextractor.h
Go to the documentation of this file.
1/* Copyright (C) 2000-2016 CEA
2 *
3 * This software and supporting documentation were developed by
4 * bioPICSEL
5 * CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
6 * 18, route du Panorama
7 * 92265 Fontenay-aux-Roses
8 * France
9 */
10
11#ifndef BRAINRAT_UTILITY_CHANNELEXTRACTOR_H
12#define BRAINRAT_UTILITY_CHANNELEXTRACTOR_H
13
14//============================================================================
15// CHANNEL EXTRACTOR
16//============================================================================
17
18//--- aims -------------------------------------------------------------------
19#include <aims/rgb/rgb.h> // AimsRGB
20#include <aims/io/io_g.h> // For debugging purpose
21//--- cartodata --------------------------------------------------------------
22#include <cartodata/volume/volume.h> // Volume
23#include <cartodata/volume/volumeutil.h> // VolumeUtil
24//--- cartobase --------------------------------------------------------------
25#include <cartobase/type/datatypetraits.h> // DataTypeTraits
26#include <cartobase/type/types.h> // DataTypeCode
27//--- std --------------------------------------------------------------------
28#include <limits> // numeric_limits
29#include <exception> // exception
30#include <cmath> // atan2
31//----------------------------------------------------------------------------
32
33namespace bio {
34
35 //--------------------------------------------------------------------------
36 // RESCALER
37 //--------------------------------------------------------------------------
42 class Rescaler
43 {
44 //------------------------------------------------------------------------
45 // constructor / destructor
46 //------------------------------------------------------------------------
47 public:
48 Rescaler():
49 _rescale( false ),
50 _imin(0.0),
51 _imax(0.0),
52 _omin(0.0),
53 _omax(0.0),
54 _iminset(false),
55 _imaxset(false),
56 _ominset(false),
57 _omaxset(false),
58 _dynlimits(true),
59 _a(0.0),
60 _b(0.0),
61 _abset(false)
62 {}
63 virtual ~Rescaler() {}
64
65 //------------------------------------------------------------------------
66 // exception
67 //------------------------------------------------------------------------
68 public:
69 class bad_options_exception: public std::exception
70 {
71 public:
72 bad_options_exception() {}
73 virtual ~bad_options_exception() throw() {};
74 virtual const char * what() const throw()
75 {
76 return "Resampler: Bad options";
77 }
78 };
79
80 //------------------------------------------------------------------------
81 // execution
82 //------------------------------------------------------------------------
83 public:
84 template <typename T, typename C>
85 C rescale( T val )
86 {
87 if( !_rescale )
88 return (C) val;
89 else if( !_abset )
90 throw bad_options_exception();
91 else
92 return (C) ( _a * (double) val + _b );
93 }
94
95 //------------------------------------------------------------------------
96 // options setting
97 //------------------------------------------------------------------------
98 public:
99 void setRescale( bool val = true ) { _rescale = val; }
100 void setInputMin( double val ) { _imin = val; _iminset = true; AB(); }
101 void setInputMax( double val ) { _imax = val; _imaxset = true; AB(); }
102 void setOutputMin( double val ) { _omin = val; _ominset = true; AB(); }
103 void setOutputMax( double val ) { _omax = val; _omaxset = true; AB(); }
104 void resetInputMin() { _iminset = false; }
105 void resetInputMax() { _imaxset = false; }
106 void resetOutputMin() { _ominset = false; }
107 void resetOutputMax() { _omaxset = false; }
108 void setInputDynMinMax( bool val = true ) { _dynlimits = val; }
109 template <typename T>
110 void setInputDynMinMax( carto::VolumeRef<T> in )
111 {
112 computeInputDynMin( in );
113 computeInputDynMax( in );
114 _iminset = true;
115 _imaxset = true;
116 AB();
117 }
118 void reset()
119 {
120 _rescale = false;
121 _iminset = false;
122 _imaxset = false;
123 _ominset = false;
124 _omaxset = false;
125 _dynlimits = true;
126 _abset = false;
127 }
128
129 //------------------------------------------------------------------------
130 // private helpers
131 //------------------------------------------------------------------------
132 protected:
133 template <typename T>
134 void computeInputDynMin( carto::VolumeRef<T> in, int ch = 0 )
135 {
136 _imin = (double) carto::VolumeUtil<T>::min( in );
137 }
138 template <typename T>
139 void computeInputDynMax( carto::VolumeRef<T> in, int ch = 0 )
140 {
141 _imax = (double) carto::VolumeUtil<T>::max( in );
142 }
143 template <typename T>
144 void computeInputTypeMin()
145 {
146 _imin = (double) std::numeric_limits<T>::min();
147 }
148 template <typename T>
149 void computeInputTypeMax()
150 {
151 _imax = (double) std::numeric_limits<T>::max();
152 }
153 template <typename C>
154 void computeOutputMin()
155 {
156 _omin = (double) std::numeric_limits<C>::min();
157 }
158 template <typename C>
159 void computeOutputMax()
160 {
161 _omax = (double) std::numeric_limits<C>::max();
162 }
163 void AB()
164 {
165 if( ( _imax != _imin ) && ( _omax != _omin ) ) {
166 _a = ( _omax - _omin ) / ( _imax - _imin );
167 _b = _omin - _a * _imin;
168 _abset = true;
169 } else
170 _abset = false;
171 }
172 template <typename T, typename C>
173 void computeRuntimeMinMax( carto::VolumeRef<T> in, int ch = 0 )
174 {
175 if( _rescale )
176 {
177 if( _dynlimits )
178 {
179 if( !_iminset )
180 computeInputDynMax( in, ch );
181 if( !_imaxset )
182 computeInputDynMax( in, ch );
183 }
184 else
185 {
186 if( !_iminset )
187 computeInputTypeMax<T>();
188 if( !_imaxset )
189 computeInputTypeMax<T>();
190 }
191 if( !_ominset )
192 computeOutputMin<C>();
193 if( !_omaxset )
194 computeOutputMax<C>();
195 AB();
196 }
197 }
198
199 //------------------------------------------------------------------------
200 // members
201 //------------------------------------------------------------------------
202 protected:
203 bool _rescale;
204 double _imin;
205 double _imax;
206 double _omin;
207 double _omax;
208 bool _iminset;
209 bool _imaxset;
210 bool _ominset;
211 bool _omaxset;
212 bool _dynlimits;
213 double _a;
214 double _b;
215 bool _abset;
216 };
217
218 //--- spec RGB -------------------------------------------------------------
219 template <>
220 void Rescaler::computeInputDynMin<AimsRGB>( carto::VolumeRef<AimsRGB> in, int ch )
221 {
222 carto::VolumeRef<AimsRGB>::const_iterator i, ie = in.end();
223 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGB>::ChannelType>::max();
224 for( i = in.begin(); i != ie; ++i )
225 {
226 if( _imin > (double) (*i)[ch] )
227 _imin = (double) (*i)[ch];
228 }
229 }
230
231 template <>
232 void Rescaler::computeInputDynMax<AimsRGB>( carto::VolumeRef<AimsRGB> in, int ch )
233 {
234 carto::VolumeRef<AimsRGB>::const_iterator i, ie = in.end();
235 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGB>::ChannelType>::min();
236 for( i = in.begin(); i != ie; ++i )
237 {
238 if( _imax > (double) (*i)[ch] )
239 _imax = (double) (*i)[ch];
240 }
241 }
242
243 template <>
244 void Rescaler::computeInputTypeMin<AimsRGB>()
245 {
246 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGB>::ChannelType>::min();
247 }
248
249 template <>
250 void Rescaler::computeInputTypeMax<AimsRGB>()
251 {
252 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGB>::ChannelType>::max();
253 }
254
255 //--- spec RGBA -------------------------------------------------------------
256 template <>
257 void Rescaler::computeInputDynMin<AimsRGBA>( carto::VolumeRef<AimsRGBA> in, int ch )
258 {
259 carto::VolumeRef<AimsRGBA>::const_iterator i, ie = in.end();
260 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGBA>::ChannelType>::max();
261 for( i = in.begin(); i != ie; ++i )
262 {
263 if( _imin > (double) (*i)[ch] )
264 _imin = (double) (*i)[ch];
265 }
266 }
267
268 template <>
269 void Rescaler::computeInputDynMax<AimsRGBA>( carto::VolumeRef<AimsRGBA> in, int ch )
270 {
271 carto::VolumeRef<AimsRGBA>::const_iterator i, ie = in.end();
272 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGBA>::ChannelType>::min();
273 for( i = in.begin(); i != ie; ++i )
274 {
275 if( _imax > (double) (*i)[ch] )
276 _imax = (double) (*i)[ch];
277 }
278 }
279
280 template <>
281 void Rescaler::computeInputTypeMin<AimsRGBA>()
282 {
283 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGBA>::ChannelType>::min();
284 }
285
286 template <>
287 void Rescaler::computeInputTypeMax<AimsRGBA>()
288 {
289 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsRGBA>::ChannelType>::max();
290 }
291
292 //--- spec HSV -------------------------------------------------------------
293 template <>
294 void Rescaler::computeInputDynMin<AimsHSV>( carto::VolumeRef<AimsHSV> in, int ch )
295 {
296 carto::VolumeRef<AimsHSV>::const_iterator i, ie = in.end();
297 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsHSV>::ChannelType>::max();
298 for( i = in.begin(); i != ie; ++i )
299 {
300 if( _imin > (double) (*i)[ch] )
301 _imin = (double) (*i)[ch];
302 }
303 }
304
305 template <>
306 void Rescaler::computeInputDynMax<AimsHSV>( carto::VolumeRef<AimsHSV> in, int ch )
307 {
308 carto::VolumeRef<AimsHSV>::const_iterator i, ie = in.end();
309 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsHSV>::ChannelType>::min();
310 for( i = in.begin(); i != ie; ++i )
311 {
312 if( _imax > (double) (*i)[ch] )
313 _imax = (double) (*i)[ch];
314 }
315 }
316
317 template <>
318 void Rescaler::computeInputTypeMin<AimsHSV>()
319 {
320 _imin = (double) std::numeric_limits<carto::DataTypeTraits<AimsHSV>::ChannelType>::min();
321 }
322
323 template <>
324 void Rescaler::computeInputTypeMax<AimsHSV>()
325 {
326 _imax = (double) std::numeric_limits<carto::DataTypeTraits<AimsHSV>::ChannelType>::max();
327 }
328
329 //--------------------------------------------------------------------------
330 // CHANNEL EXTRACTOR
331 //--------------------------------------------------------------------------
332 template <typename T, typename C>
333 class ChannelExtractor: public Rescaler
334 {
335 public:
336 ChannelExtractor():
337 Rescaler()
338 {}
339 virtual ~ChannelExtractor() {}
340
341 public:
342 class not_impl_exception: public std::exception
343 {
344 public:
345 not_impl_exception() {}
346 virtual ~not_impl_exception() throw() {};
347 virtual const char * what() const throw()
348 {
349 return ("ChannelExtractor: type " + carto::DataTypeCode<T>::name() + " not implemented").c_str();
350 }
351 };
352
353 public:
354 // write in allocated volume (need specialization)
355 void getChannelR( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
356 void getChannelG( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
357 void getChannelB( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
358 void getChannelRGBNorm( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
359 void getChannelYl( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
360 void getChannelCb( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
361 void getChannelCr( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
362 void getChannelH( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
363 void getChannelS( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
364 void getChannelV( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
365 void getChannelX( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
366 void getChannelY( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
367 void getChannelZ( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
368 void getChannelL( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
369 void getChannela( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
370 void getChannelb( carto::VolumeRef<T>, carto::VolumeRef<C> ) { throw not_impl_exception(); }
371
372 // allocate and write volume
373 carto::VolumeRef<C> getChannelR( carto::VolumeRef<T> in )
374 {
375 carto::VolumeRef<C> out = allocateVolume( in );
376 getChannelR( in, out );
377 return out;
378 }
379 carto::VolumeRef<C> getChannelG( carto::VolumeRef<T> in )
380 {
381 carto::VolumeRef<C> out = allocateVolume( in );
382 getChannelG( in, out );
383 return out;
384 }
385 carto::VolumeRef<C> getChannelB( carto::VolumeRef<T> in )
386 {
387 carto::VolumeRef<C> out = allocateVolume( in );
388 getChannelB( in, out );
389 return out;
390 }
391 carto::VolumeRef<C> getChannelRGBNorm( carto::VolumeRef<T> in )
392 {
393 carto::VolumeRef<C> out = allocateVolume( in );
394 getChannelRGBNorm( in, out );
395 return out;
396 }
397 carto::VolumeRef<C> getChannelYl( carto::VolumeRef<T> in )
398 {
399 carto::VolumeRef<C> out = allocateVolume( in );
400 getChannelYl( in, out );
401 return out;
402 }
403 carto::VolumeRef<C> getChannelCb( carto::VolumeRef<T> in )
404 {
405 carto::VolumeRef<C> out = allocateVolume( in );
406 getChannelCb( in, out );
407 return out;
408 }
409 carto::VolumeRef<C> getChannelCr( carto::VolumeRef<T> in )
410 {
411 carto::VolumeRef<C> out = allocateVolume( in );
412 getChannelCr( in, out );
413 return out;
414 }
415 carto::VolumeRef<C> getChannelH( carto::VolumeRef<T> in )
416 {
417 carto::VolumeRef<C> out = allocateVolume( in );
418 getChannelH( in, out );
419 return out;
420 }
421 carto::VolumeRef<C> getChannelS( carto::VolumeRef<T> in )
422 {
423 carto::VolumeRef<C> out = allocateVolume( in );
424 getChannelS( in, out );
425 return out;
426 }
427 carto::VolumeRef<C> getChannelV( carto::VolumeRef<T> in )
428 {
429 carto::VolumeRef<C> out = allocateVolume( in );
430 getChannelV( in, out );
431 return out;
432 }
433 carto::VolumeRef<C> getChannelX( carto::VolumeRef<T> in )
434 {
435 carto::VolumeRef<C> out = allocateVolume( in );
436 getChannelX( in, out );
437 return out;
438 }
439 carto::VolumeRef<C> getChannelY( carto::VolumeRef<T> in )
440 {
441 carto::VolumeRef<C> out = allocateVolume( in );
442 getChannelY( in, out );
443 return out;
444 }
445 carto::VolumeRef<C> getChannelZ( carto::VolumeRef<T> in )
446 {
447 carto::VolumeRef<C> out = allocateVolume( in );
448 getChannelZ( in, out );
449 return out;
450 }
451 carto::VolumeRef<C> getChannelL( carto::VolumeRef<T> in )
452 {
453 carto::VolumeRef<C> out = allocateVolume( in );
454 getChannelL( in, out );
455 return out;
456 }
457 carto::VolumeRef<C> getChannela( carto::VolumeRef<T> in )
458 {
459 carto::VolumeRef<C> out = allocateVolume( in );
460 getChannela( in, out );
461 return out;
462 }
463 carto::VolumeRef<C> getChannelb( carto::VolumeRef<T> in )
464 {
465 carto::VolumeRef<C> out = allocateVolume( in );
466 getChannelb( in, out );
467 return out;
468 }
469
470 public:
471 // helper
472 carto::VolumeRef<C> allocateVolume( carto::VolumeRef<T> in )
473 {
474 carto::VolumeRef<C> out( in.getSizeX(), in.getSizeY(),
475 in.getSizeZ(), in.getSizeT() );
476 out->copyHeaderFrom( in.header() );
477 return out;
478 }
479 };
480
481
482 //--- spec RGB -------------------------------------------------------------
483 template <typename C>
484 class ChannelExtractor<AimsRGB,C>: public Rescaler
485 {
486 public:
487 ChannelExtractor():
488 Rescaler()
489 {}
490 virtual ~ChannelExtractor() {}
491
492 // write in allocated volume
493 void getChannelR( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
494 void getChannelG( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
495 void getChannelB( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
496 void getChannelRGBNorm( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
497 void getChannelYl( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
498 void getChannelCb( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
499 void getChannelCr( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
500 void getChannelH( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
501 void getChannelS( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
502 void getChannelV( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
503 void getChannelX( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
504 void getChannelY( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
505 void getChannelZ( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
506 void getChannelL( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
507 void getChannela( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
508 void getChannelb( carto::VolumeRef<AimsRGB>, carto::VolumeRef<C> );
509
510 // allocate and write volume
511 carto::VolumeRef<C> getChannelR( carto::VolumeRef<AimsRGB> in )
512 {
513 carto::VolumeRef<C> out = allocateVolume( in );
514 getChannelR( in, out );
515 return out;
516 }
517 carto::VolumeRef<C> getChannelG( carto::VolumeRef<AimsRGB> in )
518 {
519 carto::VolumeRef<C> out = allocateVolume( in );
520 getChannelG( in, out );
521 return out;
522 }
523 carto::VolumeRef<C> getChannelB( carto::VolumeRef<AimsRGB> in )
524 {
525 carto::VolumeRef<C> out = allocateVolume( in );
526 getChannelB( in, out );
527 return out;
528 }
529 carto::VolumeRef<C> getChannelRGBNorm( carto::VolumeRef<AimsRGB> in )
530 {
531 carto::VolumeRef<C> out = allocateVolume( in );
532 getChannelRGBNorm( in, out );
533 return out;
534 }
535 carto::VolumeRef<C> getChannelYl( carto::VolumeRef<AimsRGB> in )
536 {
537 carto::VolumeRef<C> out = allocateVolume( in );
538 getChannelYl( in, out );
539 return out;
540 }
541 carto::VolumeRef<C> getChannelCb( carto::VolumeRef<AimsRGB> in )
542 {
543 carto::VolumeRef<C> out = allocateVolume( in );
544 getChannelCb( in, out );
545 return out;
546 }
547 carto::VolumeRef<C> getChannelCr( carto::VolumeRef<AimsRGB> in )
548 {
549 carto::VolumeRef<C> out = allocateVolume( in );
550 getChannelCr( in, out );
551 return out;
552 }
553 carto::VolumeRef<C> getChannelH( carto::VolumeRef<AimsRGB> in )
554 {
555 carto::VolumeRef<C> out = allocateVolume( in );
556 getChannelH( in, out );
557 return out;
558 }
559 carto::VolumeRef<C> getChannelS( carto::VolumeRef<AimsRGB> in )
560 {
561 carto::VolumeRef<C> out = allocateVolume( in );
562 getChannelS( in, out );
563 return out;
564 }
565 carto::VolumeRef<C> getChannelV( carto::VolumeRef<AimsRGB> in )
566 {
567 carto::VolumeRef<C> out = allocateVolume( in );
568 getChannelV( in, out );
569 return out;
570 }
571 carto::VolumeRef<C> getChannelX( carto::VolumeRef<AimsRGB> in )
572 {
573 carto::VolumeRef<C> out = allocateVolume( in );
574 getChannelX( in, out );
575 return out;
576 }
577 carto::VolumeRef<C> getChannelY( carto::VolumeRef<AimsRGB> in )
578 {
579 carto::VolumeRef<C> out = allocateVolume( in );
580 getChannelY( in, out );
581 return out;
582 }
583 carto::VolumeRef<C> getChannelZ( carto::VolumeRef<AimsRGB> in )
584 {
585 carto::VolumeRef<C> out = allocateVolume( in );
586 getChannelZ( in, out );
587 return out;
588 }
589 carto::VolumeRef<C> getChannelL( carto::VolumeRef<AimsRGB> in )
590 {
591 carto::VolumeRef<C> out = allocateVolume( in );
592 getChannelL( in, out );
593 return out;
594 }
595 carto::VolumeRef<C> getChannela( carto::VolumeRef<AimsRGB> in )
596 {
597 carto::VolumeRef<C> out = allocateVolume( in );
598 getChannela( in, out );
599 return out;
600 }
601 carto::VolumeRef<C> getChannelb( carto::VolumeRef<AimsRGB> in )
602 {
603 carto::VolumeRef<C> out = allocateVolume( in );
604 getChannelb( in, out );
605 return out;
606 }
607
608 protected:
609 // helper
610 carto::VolumeRef<C> allocateVolume( carto::VolumeRef<AimsRGB> in )
611 {
612 carto::VolumeRef<C> out( in.getSizeX(), in.getSizeY(),
613 in.getSizeZ(), in.getSizeT() );
614 out->copyHeaderFrom( in.header() );
615 return out;
616 }
617 };
618
619 template <typename C>
620 void ChannelExtractor<AimsRGB,C>::getChannelR( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
621 {
622 computeRuntimeMinMax<AimsRGB,C>( in, 0 );
623
624 long dimx = in.getSizeX(),
625 dimy = in.getSizeY(),
626 dimz = in.getSizeZ(),
627 dimt = in.getSizeT();
628 for( long t=0; t< dimt; ++t )
629 for( long z=0; z< dimz; ++z )
630 for( long y=0; y< dimy; ++y )
631 for( long x=0; x< dimx; ++x )
632 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGB>::ChannelType,C>( in( x, y, z, t ).red() );
633 }
634
635 template <typename C>
636 void ChannelExtractor<AimsRGB,C>::getChannelG( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
637 {
638 computeRuntimeMinMax<AimsRGB,C>( in, 1 );
639
640 long dimx = in.getSizeX(),
641 dimy = in.getSizeY(),
642 dimz = in.getSizeZ(),
643 dimt = in.getSizeT();
644 for( long t=0; t< dimt; ++t )
645 for( long z=0; z< dimz; ++z )
646 for( long y=0; y< dimy; ++y )
647 for( long x=0; x< dimx; ++x )
648 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGB>::ChannelType,C>( in( x, y, z, t ).green() );
649 }
650
651 template <typename C>
652 void ChannelExtractor<AimsRGB,C>::getChannelB( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
653 {
654 computeRuntimeMinMax<AimsRGB,C>( in, 2 );
655
656 long dimx = in.getSizeX(),
657 dimy = in.getSizeY(),
658 dimz = in.getSizeZ(),
659 dimt = in.getSizeT();
660 for( long t=0; t< dimt; ++t )
661 for( long z=0; z< dimz; ++z )
662 for( long y=0; y< dimy; ++y )
663 for( long x=0; x< dimx; ++x )
664 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGB>::ChannelType,C>( in( x, y, z, t ).blue() );
665 }
666
667 template <typename C>
668 void ChannelExtractor<AimsRGB,C>::getChannelRGBNorm( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
669 {
670 computeRuntimeMinMax<AimsRGB,C>( in );
671
672 double val;
673 long dimx = in.getSizeX(),
674 dimy = in.getSizeY(),
675 dimz = in.getSizeZ(),
676 dimt = in.getSizeT();
677 for( long t=0; t< dimt; ++t )
678 for( long z=0; z< dimz; ++z )
679 for( long y=0; y< dimy; ++y )
680 for( long x=0; x< dimx; ++x )
681 {
682 val = (double) in( x, y, z, t ).red()
683 + (double) in( x, y, z, t ).green()
684 + (double) in( x, y, z, t ).blue();
685 val /= 3;
686 out( x, y, z, t ) = rescale<double,C>( val );
687 }
688 }
689
690 template <typename C>
691 void ChannelExtractor<AimsRGB,C>::getChannelYl( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
692 {
693 computeRuntimeMinMax<AimsRGB,C>( in );
694
695 double val;
696 long dimx = in.getSizeX(),
697 dimy = in.getSizeY(),
698 dimz = in.getSizeZ(),
699 dimt = in.getSizeT();
700 for( long t=0; t< dimt; ++t )
701 for( long z=0; z< dimz; ++z )
702 for( long y=0; y< dimy; ++y )
703 for( long x=0; x< dimx; ++x )
704 {
705 val = 0.299 * (double) in( x, y, z, t ).red()
706 + 0.587 * (double) in( x, y, z, t ).green()
707 + 0.114 * (double) in( x, y, z, t ).blue();
708 out( x, y, z, t ) = rescale<double,C>( val );
709 }
710 }
711
712 template <typename C>
713 void ChannelExtractor<AimsRGB,C>::getChannelCb( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
714 {
715 computeRuntimeMinMax<AimsRGB,C>( in );
716
717 double val;
718 long dimx = in.getSizeX(),
719 dimy = in.getSizeY(),
720 dimz = in.getSizeZ(),
721 dimt = in.getSizeT();
722 for( long t=0; t< dimt; ++t )
723 for( long z=0; z< dimz; ++z )
724 for( long y=0; y< dimy; ++y )
725 for( long x=0; x< dimx; ++x )
726 {
727 val = - 0.1687 * (double) in( x, y, z, t ).red()
728 - 0.3313 * (double) in( x, y, z, t ).green()
729 + 0.5 * (double) in( x, y, z, t ).blue()
730 + 128;
731 out( x, y, z, t ) = rescale<double,C>( val );
732 }
733 }
734
735 template <typename C>
736 void ChannelExtractor<AimsRGB,C>::getChannelCr( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
737 {
738 computeRuntimeMinMax<AimsRGB,C>( in );
739
740 double val;
741 long dimx = in.getSizeX(),
742 dimy = in.getSizeY(),
743 dimz = in.getSizeZ(),
744 dimt = in.getSizeT();
745 for( long t=0; t< dimt; ++t )
746 for( long z=0; z< dimz; ++z )
747 for( long y=0; y< dimy; ++y )
748 for( long x=0; x< dimx; ++x )
749 {
750 val = 0.5 * (double) in( x, y, z, t ).red()
751 - 0.4187 * (double) in( x, y, z, t ).green()
752 - 0.0813 * (double) in( x, y, z, t ).blue()
753 + 128;
754 out( x, y, z, t ) = rescale<double,C>( val );
755 }
756 }
757
758 template <typename C>
759 void ChannelExtractor<AimsRGB,C>::getChannelH( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
760 {
761 computeRuntimeMinMax<AimsRGB,C>( in );
762
763 double val;
764 long dimx = in.getSizeX(),
765 dimy = in.getSizeY(),
766 dimz = in.getSizeZ(),
767 dimt = in.getSizeT();
768 for( long t=0; t< dimt; ++t )
769 for( long z=0; z< dimz; ++z )
770 for( long y=0; y< dimy; ++y )
771 for( long x=0; x< dimx; ++x )
772 {
773 val = std::atan2( std::sqrt(3) * (
774 (double) in( x, y, z, t ).green() -
775 (double) in( x, y, z, t ).blue() ),
776 (double) 2.0 * (
777 (double) in( x, y, z, t ).red() -
778 (double) in( x, y, z, t ).green() -
779 (double) in( x, y, z, t ).blue() )
780 );
781 out( x, y, z, t ) = rescale<double,C>( val );
782 }
783 }
784
785 template <typename C>
786 void ChannelExtractor<AimsRGB,C>::getChannelS( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
787 {
788 computeRuntimeMinMax<AimsRGB,C>( in );
789 double val, min, max;
790 long dimx = in.getSizeX(),
791 dimy = in.getSizeY(),
792 dimz = in.getSizeZ(),
793 dimt = in.getSizeT();
794 for( long t=0; t< dimt; ++t )
795 for( long z=0; z< dimz; ++z )
796 for( long y=0; y< dimy; ++y )
797 for( long x=0; x< dimx; ++x )
798 {
799 min = ( in( x, y, z, t ).red() <= in( x, y, z, t ).green()
800 ? (double) in( x, y, z, t ).red()
801 : (double) in( x, y, z, t ).green() );
802 min = ( min <= (double) in( x, y, z, t ).blue()
803 ? min
804 : in( x, y, z, t ).blue() );
805 max = ( in( x, y, z, t ).red() >= in( x, y, z, t ).green()
806 ? (double) in( x, y, z, t ).red()
807 : (double) in( x, y, z, t ).green() );
808 max = ( max >= (double) in( x, y, z, t ).blue()
809 ? max
810 : in( x, y, z, t ).blue() );
811 val = ( max == 0 ? max : 1.0 - min / max );
812 out( x, y, z, t ) = rescale<double,C>( val );
813 }
814 }
815
816 template <typename C>
817 void ChannelExtractor<AimsRGB,C>::getChannelV( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
818 {
819 computeRuntimeMinMax<AimsRGB,C>( in );
820 double max;
821 long dimx = in.getSizeX(),
822 dimy = in.getSizeY(),
823 dimz = in.getSizeZ(),
824 dimt = in.getSizeT();
825 for( long t=0; t< dimt; ++t )
826 for( long z=0; z< dimz; ++z )
827 for( long y=0; y< dimy; ++y )
828 for( long x=0; x< dimx; ++x )
829 {
830 max = ( in( x, y, z, t ).red() >= in( x, y, z, t ).green()
831 ? (double) in( x, y, z, t ).red()
832 : (double) in( x, y, z, t ).green() );
833 max = ( max >= (double) in( x, y, z, t ).blue()
834 ? max
835 : in( x, y, z, t ).blue() );
836 out( x, y, z, t ) = rescale<double,C>( max );
837 }
838 }
839
840 template <typename C>
841 void ChannelExtractor<AimsRGB,C>::getChannelX( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
842 {
843 computeRuntimeMinMax<AimsRGB,C>( in );
844 double valin[3];
845 double valout;
846 long dimx = in.getSizeX(),
847 dimy = in.getSizeY(),
848 dimz = in.getSizeZ(),
849 dimt = in.getSizeT();
850 for( long t=0; t< dimt; ++t )
851 for( long z=0; z< dimz; ++z )
852 for( long y=0; y< dimy; ++y )
853 for( long x=0; x< dimx; ++x )
854 {
855 valin[0] = ((double) in( x, y, z, t ).red())/255;
856 valin[1] = ((double) in( x, y, z, t ).green())/255;
857 valin[2] = ((double) in( x, y, z, t ).blue())/255;
858
859 for( int n=0; n<3; ++n){
860 if( valin[n] > 0.04045 )
861 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
862 else
863 valin[n] = valin[n]/12.92;
864 }
865
866 valout = 0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[2];
867 valout *= 100;
868
869 out( x, y, z, t ) = rescale<double,C>( valout );
870 }
871 }
872
873 template <typename C>
874 void ChannelExtractor<AimsRGB,C>::getChannelY( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
875 {
876 computeRuntimeMinMax<AimsRGB,C>( in );
877 double valin[3];
878 double valout;
879 long dimx = in.getSizeX(),
880 dimy = in.getSizeY(),
881 dimz = in.getSizeZ(),
882 dimt = in.getSizeT();
883 for( long t=0; t< dimt; ++t )
884 for( long z=0; z< dimz; ++z )
885 for( long y=0; y< dimy; ++y )
886 for( long x=0; x< dimx; ++x )
887 {
888 valin[0] = ((double) in( x, y, z, t ).red())/255;
889 valin[1] = ((double) in( x, y, z, t ).green())/255;
890 valin[2] = ((double) in( x, y, z, t ).blue())/255;
891
892 for( int n=0; n<3; ++n){
893 if( valin[n] > 0.04045 )
894 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
895 else
896 valin[n] = valin[n]/12.92;
897 }
898
899 valout = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
900 valout *= 100;
901
902 out( x, y, z, t ) = rescale<double,C>( valout );
903 }
904 }
905
906 template <typename C>
907 void ChannelExtractor<AimsRGB,C>::getChannelZ( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
908 {
909 computeRuntimeMinMax<AimsRGB,C>( in );
910 double valin[3];
911 double valout;
912 long dimx = in.getSizeX(),
913 dimy = in.getSizeY(),
914 dimz = in.getSizeZ(),
915 dimt = in.getSizeT();
916 for( long t=0; t< dimt; ++t )
917 for( long z=0; z< dimz; ++z )
918 for( long y=0; y< dimy; ++y )
919 for( long x=0; x< dimx; ++x )
920 {
921 valin[0] = ((double) in( x, y, z, t ).red())/255;
922 valin[1] = ((double) in( x, y, z, t ).green())/255;
923 valin[2] = ((double) in( x, y, z, t ).blue())/255;
924
925 for( int n=0; n<3; ++n){
926 if( valin[n] > 0.04045 )
927 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
928 else
929 valin[n] = valin[n]/12.92;
930 }
931
932 valout = 0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2];
933 valout *= 100;
934
935 out( x, y, z, t ) = rescale<double,C>( valout );
936 }
937 }
938
939 template <typename C>
940 void ChannelExtractor<AimsRGB,C>::getChannelL( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
941 {
942 computeRuntimeMinMax<AimsRGB,C>( in );
943 double valin[3];
944 double valX, valY, valZ, valout;
945 long dimx = in.getSizeX(),
946 dimy = in.getSizeY(),
947 dimz = in.getSizeZ(),
948 dimt = in.getSizeT();
949 for( long t=0; t< dimt; ++t )
950 for( long z=0; z< dimz; ++z )
951 for( long y=0; y< dimy; ++y )
952 for( long x=0; x< dimx; ++x )
953 {
954 valin[0] = ((double) in( x, y, z, t ).red())/255;
955 valin[1] = ((double) in( x, y, z, t ).green())/255;
956 valin[2] = ((double) in( x, y, z, t ).blue())/255;
957
958 for( int n=0; n<3; ++n){
959 if( valin[n] > 0.04045 )
960 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
961 else
962 valin[n] = valin[n]/12.92;
963 }
964
965 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
966
967 if( valY > 0.008856 ) {
968 valout = std::pow(valY, 0.333333);
969 } else {
970 valout = 7.787*valY + ((double)16/116);
971 }
972
973 valout = 116*valout - 16;
974
975 out( x, y, z, t ) = rescale<double,C>( valout );
976 }
977 }
978
979 template <typename C>
980 void ChannelExtractor<AimsRGB,C>::getChannela( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
981 {
982 computeRuntimeMinMax<AimsRGB,C>( in );
983 double valin[3];
984 double valX, valY, valZ, valout;
985 long dimx = in.getSizeX(),
986 dimy = in.getSizeY(),
987 dimz = in.getSizeZ(),
988 dimt = in.getSizeT();
989 for( long t=0; t< dimt; ++t )
990 for( long z=0; z< dimz; ++z )
991 for( long y=0; y< dimy; ++y )
992 for( long x=0; x< dimx; ++x )
993 {
994 valin[0] = ((double) in( x, y, z, t ).red())/255;
995 valin[1] = ((double) in( x, y, z, t ).green())/255;
996 valin[2] = ((double) in( x, y, z, t ).blue())/255;
997
998 for( int n=0; n<3; ++n){
999 if( valin[n] > 0.04045 )
1000 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1001 else
1002 valin[n] = valin[n]/12.92;
1003 }
1004
1005 valX = (0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[2])*((double)100/95.047);
1006 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1007
1008 valout = 0.0;
1009 if( valX > 0.008856 ) {
1010 valout += std::pow(valX, 0.333333);
1011 } else {
1012 valout += 7.787*valX + ((double)16/116);
1013 }
1014 if( valY > 0.008856 ) {
1015 valout -= std::pow(valY, 0.333333);
1016 } else {
1017 valout -= 7.787*valY + ((double)16/116);
1018 }
1019 valout *= 500;
1020
1021 out( x, y, z, t ) = rescale<double,C>( valout );
1022 }
1023 }
1024
1025 template <typename C>
1026 void ChannelExtractor<AimsRGB,C>::getChannelb( carto::VolumeRef<AimsRGB> in, carto::VolumeRef<C> out )
1027 {
1028 computeRuntimeMinMax<AimsRGB,C>( in );
1029 double valin[3];
1030 double valX, valY, valZ, valout;
1031 long dimx = in.getSizeX(),
1032 dimy = in.getSizeY(),
1033 dimz = in.getSizeZ(),
1034 dimt = in.getSizeT();
1035 for( long t=0; t< dimt; ++t )
1036 for( long z=0; z< dimz; ++z )
1037 for( long y=0; y< dimy; ++y )
1038 for( long x=0; x< dimx; ++x )
1039 {
1040 valin[0] = ((double) in( x, y, z, t ).red())/255;
1041 valin[1] = ((double) in( x, y, z, t ).green())/255;
1042 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1043
1044 for( int n=0; n<3; ++n){
1045 if( valin[n] > 0.04045 )
1046 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1047 else
1048 valin[n] = valin[n]/12.92;
1049 }
1050
1051 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1052 valZ = (0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2])*((double)100/108.883);
1053
1054 valout = 0.0;
1055 if( valY > 0.008856 ) {
1056 valout += std::pow(valY, 0.333333);
1057 } else {
1058 valout += 7.787*valY + ((double)16/116);
1059 }
1060 if( valZ > 0.008856 ) {
1061 valout -= std::pow(valZ, 0.333333);
1062 } else {
1063 valout -= 7.787*valZ + ((double)16/116);
1064 }
1065 valout *= 200;
1066
1067 out( x, y, z, t ) = rescale<double,C>( valout );
1068 }
1069 }
1070
1071 //--- spec RGBA -------------------------------------------------------------
1072 template <typename C>
1073 class ChannelExtractor<AimsRGBA,C>: public Rescaler
1074 {
1075 public:
1076 ChannelExtractor():
1077 Rescaler()
1078 {}
1079 virtual ~ChannelExtractor() {}
1080
1081 // write in allocated volume
1082 void getChannelR( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1083 void getChannelG( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1084 void getChannelB( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1085 void getChannelA( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1086 void getChannelRGBNorm( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1087 void getChannelYl( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1088 void getChannelCb( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1089 void getChannelCr( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1090 void getChannelH( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1091 void getChannelS( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1092 void getChannelV( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1093 void getChannelX( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1094 void getChannelY( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1095 void getChannelZ( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1096 void getChannelL( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1097 void getChannela( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1098 void getChannelb( carto::VolumeRef<AimsRGBA>, carto::VolumeRef<C> );
1099
1100 // allocate and write volume
1101 carto::VolumeRef<C> getChannelR( carto::VolumeRef<AimsRGBA> in )
1102 {
1103 carto::VolumeRef<C> out = allocateVolume( in );
1104 getChannelR( in, out );
1105 return out;
1106 }
1107 carto::VolumeRef<C> getChannelG( carto::VolumeRef<AimsRGBA> in )
1108 {
1109 carto::VolumeRef<C> out = allocateVolume( in );
1110 getChannelG( in, out );
1111 return out;
1112 }
1113 carto::VolumeRef<C> getChannelB( carto::VolumeRef<AimsRGBA> in )
1114 {
1115 carto::VolumeRef<C> out = allocateVolume( in );
1116 getChannelB( in, out );
1117 return out;
1118 }
1119 carto::VolumeRef<C> getChannelA( carto::VolumeRef<AimsRGBA> in )
1120 {
1121 carto::VolumeRef<C> out = allocateVolume( in );
1122 getChannelA( in, out );
1123 return out;
1124 }
1125 carto::VolumeRef<C> getChannelRGBNorm( carto::VolumeRef<AimsRGBA> in )
1126 {
1127 carto::VolumeRef<C> out = allocateVolume( in );
1128 getChannelRGBNorm( in, out );
1129 return out;
1130 }
1131 carto::VolumeRef<C> getChannelYl( carto::VolumeRef<AimsRGBA> in )
1132 {
1133 carto::VolumeRef<C> out = allocateVolume( in );
1134 getChannelYl( in, out );
1135 return out;
1136 }
1137 carto::VolumeRef<C> getChannelCb( carto::VolumeRef<AimsRGBA> in )
1138 {
1139 carto::VolumeRef<C> out = allocateVolume( in );
1140 getChannelCb( in, out );
1141 return out;
1142 }
1143 carto::VolumeRef<C> getChannelCr( carto::VolumeRef<AimsRGBA> in )
1144 {
1145 carto::VolumeRef<C> out = allocateVolume( in );
1146 getChannelCr( in, out );
1147 return out;
1148 }
1149 carto::VolumeRef<C> getChannelH( carto::VolumeRef<AimsRGBA> in )
1150 {
1151 carto::VolumeRef<C> out = allocateVolume( in );
1152 getChannelH( in, out );
1153 return out;
1154 }
1155 carto::VolumeRef<C> getChannelS( carto::VolumeRef<AimsRGBA> in )
1156 {
1157 carto::VolumeRef<C> out = allocateVolume( in );
1158 getChannelS( in, out );
1159 return out;
1160 }
1161 carto::VolumeRef<C> getChannelV( carto::VolumeRef<AimsRGBA> in )
1162 {
1163 carto::VolumeRef<C> out = allocateVolume( in );
1164 getChannelV( in, out );
1165 return out;
1166 }
1167 carto::VolumeRef<C> getChannelX( carto::VolumeRef<AimsRGBA> in )
1168 {
1169 carto::VolumeRef<C> out = allocateVolume( in );
1170 getChannelX( in, out );
1171 return out;
1172 }
1173 carto::VolumeRef<C> getChannelY( carto::VolumeRef<AimsRGBA> in )
1174 {
1175 carto::VolumeRef<C> out = allocateVolume( in );
1176 getChannelY( in, out );
1177 return out;
1178 }
1179 carto::VolumeRef<C> getChannelZ( carto::VolumeRef<AimsRGBA> in )
1180 {
1181 carto::VolumeRef<C> out = allocateVolume( in );
1182 getChannelZ( in, out );
1183 return out;
1184 }
1185 carto::VolumeRef<C> getChannelL( carto::VolumeRef<AimsRGBA> in )
1186 {
1187 carto::VolumeRef<C> out = allocateVolume( in );
1188 getChannelL( in, out );
1189 return out;
1190 }
1191 carto::VolumeRef<C> getChannela( carto::VolumeRef<AimsRGBA> in )
1192 {
1193 carto::VolumeRef<C> out = allocateVolume( in );
1194 getChannela( in, out );
1195 return out;
1196 }
1197 carto::VolumeRef<C> getChannelb( carto::VolumeRef<AimsRGBA> in )
1198 {
1199 carto::VolumeRef<C> out = allocateVolume( in );
1200 getChannelb( in, out );
1201 return out;
1202 }
1203
1204 protected:
1205 // helper
1206 carto::VolumeRef<C> allocateVolume( carto::VolumeRef<AimsRGBA> in )
1207 {
1208 carto::VolumeRef<C> out( in.getSizeX(), in.getSizeY(),
1209 in.getSizeZ(), in.getSizeT() );
1210 out->copyHeaderFrom( in.header() );
1211 return out;
1212 }
1213 };
1214
1215 template <typename C>
1216 void ChannelExtractor<AimsRGBA,C>::getChannelR( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1217 {
1218 computeRuntimeMinMax<AimsRGBA,C>( in, 0 );
1219
1220 long dimx = in.getSizeX(),
1221 dimy = in.getSizeY(),
1222 dimz = in.getSizeZ(),
1223 dimt = in.getSizeT();
1224 for( long t=0; t< dimt; ++t )
1225 for( long z=0; z< dimz; ++z )
1226 for( long y=0; y< dimy; ++y )
1227 for( long x=0; x< dimx; ++x )
1228 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGBA>::ChannelType,C>( in( x, y, z, t ).red() );
1229 }
1230
1231 template <typename C>
1232 void ChannelExtractor<AimsRGBA,C>::getChannelG( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1233 {
1234 computeRuntimeMinMax<AimsRGBA,C>( in, 1 );
1235
1236 long dimx = in.getSizeX(),
1237 dimy = in.getSizeY(),
1238 dimz = in.getSizeZ(),
1239 dimt = in.getSizeT();
1240 for( long t=0; t< dimt; ++t )
1241 for( long z=0; z< dimz; ++z )
1242 for( long y=0; y< dimy; ++y )
1243 for( long x=0; x< dimx; ++x )
1244 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGBA>::ChannelType,C>( in( x, y, z, t ).green() );
1245 }
1246
1247 template <typename C>
1248 void ChannelExtractor<AimsRGBA,C>::getChannelB( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1249 {
1250 computeRuntimeMinMax<AimsRGBA,C>( in, 2 );
1251
1252 long dimx = in.getSizeX(),
1253 dimy = in.getSizeY(),
1254 dimz = in.getSizeZ(),
1255 dimt = in.getSizeT();
1256 for( long t=0; t< dimt; ++t )
1257 for( long z=0; z< dimz; ++z )
1258 for( long y=0; y< dimy; ++y )
1259 for( long x=0; x< dimx; ++x )
1260 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGBA>::ChannelType,C>( in( x, y, z, t ).blue() );
1261 }
1262
1263 template <typename C>
1264 void ChannelExtractor<AimsRGBA,C>::getChannelA( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1265 {
1266 computeRuntimeMinMax<AimsRGBA,C>( in, 3 );
1267
1268 long dimx = in.getSizeX(),
1269 dimy = in.getSizeY(),
1270 dimz = in.getSizeZ(),
1271 dimt = in.getSizeT();
1272 for( long t=0; t< dimt; ++t )
1273 for( long z=0; z< dimz; ++z )
1274 for( long y=0; y< dimy; ++y )
1275 for( long x=0; x< dimx; ++x )
1276 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsRGBA>::ChannelType,C>( in( x, y, z, t ).alpha() );
1277 }
1278
1279 template <typename C>
1280 void ChannelExtractor<AimsRGBA,C>::getChannelRGBNorm(
1281 carto::VolumeRef<AimsRGBA> in,
1282 carto::VolumeRef<C> out)
1283 {
1284 computeRuntimeMinMax<AimsRGBA,C>( in );
1285
1286// std::cout << "==== ChannelExtractor<AimsRGBA,C>::getChannelRGBNorm "
1287// << "rescale: " << carto::toString(_rescale) << ", "
1288// << carto::toString(this->_a)
1289// << "x + " << carto::toString(this->_b) << "]"
1290// << std::endl << std::flush;
1291// std::cout << "==== ChannelExtractor<AimsRGBA,C>::getChannelRGBNorm "
1292// << "input range: ["<< carto::toString(this->_imin)
1293// << "-" << carto::toString(this->_imax) << "], "
1294// << "output range: ["<< carto::toString(this->_omin)
1295// << "-" << carto::toString(this->_omax) << "]"
1296// << std::endl << std::flush;
1297
1298 double val;
1299
1300 long dimx = in.getSizeX(),
1301 dimy = in.getSizeY(),
1302 dimz = in.getSizeZ(),
1303 dimt = in.getSizeT();
1304 for( long t=0; t< dimt; ++t )
1305 for( long z=0; z< dimz; ++z )
1306 for( long y=0; y< dimy; ++y )
1307 for( long x=0; x< dimx; ++x )
1308 {
1309 val = (double) in( x, y, z, t ).red()
1310 + (double) in( x, y, z, t ).green()
1311 + (double) in( x, y, z, t ).blue();
1312 val /= 3;
1313 out( x, y, z, t ) = rescale<double,C>( val );
1314 }
1315 }
1316
1317 template <typename C>
1318 void ChannelExtractor<AimsRGBA,C>::getChannelYl( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1319 {
1320 computeRuntimeMinMax<AimsRGBA,C>( in );
1321
1322 double val;
1323 long dimx = in.getSizeX(),
1324 dimy = in.getSizeY(),
1325 dimz = in.getSizeZ(),
1326 dimt = in.getSizeT();
1327 for( long t=0; t< dimt; ++t )
1328 for( long z=0; z< dimz; ++z )
1329 for( long y=0; y< dimy; ++y )
1330 for( long x=0; x< dimx; ++x )
1331 {
1332 val = 0.299 * (double) in( x, y, z, t ).red()
1333 + 0.587 * (double) in( x, y, z, t ).green()
1334 + 0.114 * (double) in( x, y, z, t ).blue();
1335 out( x, y, z, t ) = rescale<double,C>( val );
1336 }
1337 }
1338
1339 template <typename C>
1340 void ChannelExtractor<AimsRGBA,C>::getChannelCb( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1341 {
1342 computeRuntimeMinMax<AimsRGBA,C>( in );
1343
1344 double val;
1345 long dimx = in.getSizeX(),
1346 dimy = in.getSizeY(),
1347 dimz = in.getSizeZ(),
1348 dimt = in.getSizeT();
1349 for( long t=0; t< dimt; ++t )
1350 for( long z=0; z< dimz; ++z )
1351 for( long y=0; y< dimy; ++y )
1352 for( long x=0; x< dimx; ++x )
1353 {
1354 val = - 0.1687 * (double) in( x, y, z, t ).red()
1355 - 0.3313 * (double) in( x, y, z, t ).green()
1356 + 0.5 * (double) in( x, y, z, t ).blue()
1357 + 128;
1358 out( x, y, z, t ) = rescale<double,C>( val );
1359 }
1360 }
1361
1362 template <typename C>
1363 void ChannelExtractor<AimsRGBA,C>::getChannelCr( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1364 {
1365 computeRuntimeMinMax<AimsRGBA,C>( in );
1366
1367 double val;
1368 long dimx = in.getSizeX(),
1369 dimy = in.getSizeY(),
1370 dimz = in.getSizeZ(),
1371 dimt = in.getSizeT();
1372 for( long t=0; t< dimt; ++t )
1373 for( long z=0; z< dimz; ++z )
1374 for( long y=0; y< dimy; ++y )
1375 for( long x=0; x< dimx; ++x )
1376 {
1377 val = 0.5 * (double) in( x, y, z, t ).red()
1378 - 0.4187 * (double) in( x, y, z, t ).green()
1379 - 0.0813 * (double) in( x, y, z, t ).blue()
1380 + 128;
1381 out( x, y, z, t ) = rescale<double,C>( val );
1382 }
1383 }
1384
1385 template <typename C>
1386 void ChannelExtractor<AimsRGBA,C>::getChannelH( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1387 {
1388 computeRuntimeMinMax<AimsRGBA,C>( in );
1389
1390 double val;
1391 long dimx = in.getSizeX(),
1392 dimy = in.getSizeY(),
1393 dimz = in.getSizeZ(),
1394 dimt = in.getSizeT();
1395 for( long t=0; t< dimt; ++t )
1396 for( long z=0; z< dimz; ++z )
1397 for( long y=0; y< dimy; ++y )
1398 for( long x=0; x< dimx; ++x )
1399 {
1400 val = std::atan2( std::sqrt(3) * (
1401 (double) in( x, y, z, t ).green() -
1402 (double) in( x, y, z, t ).blue() ),
1403 (double) 2.0 * (
1404 (double) in( x, y, z, t ).red() -
1405 (double) in( x, y, z, t ).green() -
1406 (double) in( x, y, z, t ).blue() )
1407 );
1408 out( x, y, z, t ) = rescale<double,C>( val );
1409 }
1410 }
1411
1412 template <typename C>
1413 void ChannelExtractor<AimsRGBA,C>::getChannelS( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1414 {
1415 computeRuntimeMinMax<AimsRGBA,C>( in );
1416 double val, min, max;
1417 long dimx = in.getSizeX(),
1418 dimy = in.getSizeY(),
1419 dimz = in.getSizeZ(),
1420 dimt = in.getSizeT();
1421 for( long t=0; t< dimt; ++t )
1422 for( long z=0; z< dimz; ++z )
1423 for( long y=0; y< dimy; ++y )
1424 for( long x=0; x< dimx; ++x )
1425 {
1426 min = ( in( x, y, z, t ).red() <= in( x, y, z, t ).green()
1427 ? (double) in( x, y, z, t ).red()
1428 : (double) in( x, y, z, t ).green() );
1429 min = ( min <= (double) in( x, y, z, t ).blue()
1430 ? min
1431 : in( x, y, z, t ).blue() );
1432 max = ( in( x, y, z, t ).red() >= in( x, y, z, t ).green()
1433 ? (double) in( x, y, z, t ).red()
1434 : (double) in( x, y, z, t ).green() );
1435 max = ( max >= (double) in( x, y, z, t ).blue()
1436 ? max
1437 : in( x, y, z, t ).blue() );
1438 val = ( max == 0 ? max : 1.0 - min / max );
1439 out( x, y, z, t ) = rescale<double,C>( val );
1440 }
1441 }
1442
1443 template <typename C>
1444 void ChannelExtractor<AimsRGBA,C>::getChannelV( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1445 {
1446 computeRuntimeMinMax<AimsRGBA,C>( in );
1447 double max;
1448 long dimx = in.getSizeX(),
1449 dimy = in.getSizeY(),
1450 dimz = in.getSizeZ(),
1451 dimt = in.getSizeT();
1452 for( long t=0; t< dimt; ++t )
1453 for( long z=0; z< dimz; ++z )
1454 for( long y=0; y< dimy; ++y )
1455 for( long x=0; x< dimx; ++x )
1456 {
1457 max = ( in( x, y, z, t ).red() >= in( x, y, z, t ).green()
1458 ? (double) in( x, y, z, t ).red()
1459 : (double) in( x, y, z, t ).green() );
1460 max = ( max >= (double) in( x, y, z, t ).blue()
1461 ? max
1462 : in( x, y, z, t ).blue() );
1463 out( x, y, z, t ) = rescale<double,C>( max );
1464 }
1465 }
1466
1467 template <typename C>
1468 void ChannelExtractor<AimsRGBA,C>::getChannelX( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1469 {
1470 computeRuntimeMinMax<AimsRGBA,C>( in );
1471 double valin[3];
1472 double valout;
1473 long dimx = in.getSizeX(),
1474 dimy = in.getSizeY(),
1475 dimz = in.getSizeZ(),
1476 dimt = in.getSizeT();
1477 for( long t=0; t< dimt; ++t )
1478 for( long z=0; z< dimz; ++z )
1479 for( long y=0; y< dimy; ++y )
1480 for( long x=0; x< dimx; ++x )
1481 {
1482 valin[0] = ((double) in( x, y, z, t ).red())/255;
1483 valin[1] = ((double) in( x, y, z, t ).green())/255;
1484 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1485
1486 for( int n=0; n<3; ++n){
1487 if( valin[n] > 0.04045 )
1488 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1489 else
1490 valin[n] = valin[n]/12.92;
1491 }
1492
1493 valout = 0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[2];
1494 valout *= 100;
1495
1496 out( x, y, z, t ) = rescale<double,C>( valout );
1497 }
1498 }
1499
1500 template <typename C>
1501 void ChannelExtractor<AimsRGBA,C>::getChannelY( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1502 {
1503 computeRuntimeMinMax<AimsRGBA,C>( in );
1504 double valin[3];
1505 double valout;
1506 long dimx = in.getSizeX(),
1507 dimy = in.getSizeY(),
1508 dimz = in.getSizeZ(),
1509 dimt = in.getSizeT();
1510 for( long t=0; t< dimt; ++t )
1511 for( long z=0; z< dimz; ++z )
1512 for( long y=0; y< dimy; ++y )
1513 for( long x=0; x< dimx; ++x )
1514 {
1515 valin[0] = ((double) in( x, y, z, t ).red())/255;
1516 valin[1] = ((double) in( x, y, z, t ).green())/255;
1517 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1518
1519 for( int n=0; n<3; ++n){
1520 if( valin[n] > 0.04045 )
1521 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1522 else
1523 valin[n] = valin[n]/12.92;
1524 }
1525
1526 valout = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1527 valout *= 100;
1528
1529 out( x, y, z, t ) = rescale<double,C>( valout );
1530 }
1531 }
1532
1533 template <typename C>
1534 void ChannelExtractor<AimsRGBA,C>::getChannelZ( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1535 {
1536 computeRuntimeMinMax<AimsRGBA,C>( in );
1537 double valin[3];
1538 double valout;
1539 long dimx = in.getSizeX(),
1540 dimy = in.getSizeY(),
1541 dimz = in.getSizeZ(),
1542 dimt = in.getSizeT();
1543 for( long t=0; t< dimt; ++t )
1544 for( long z=0; z< dimz; ++z )
1545 for( long y=0; y< dimy; ++y )
1546 for( long x=0; x< dimx; ++x )
1547 {
1548 valin[0] = ((double) in( x, y, z, t ).red())/255;
1549 valin[1] = ((double) in( x, y, z, t ).green())/255;
1550 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1551
1552 for( int n=0; n<3; ++n){
1553 if( valin[n] > 0.04045 )
1554 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1555 else
1556 valin[n] = valin[n]/12.92;
1557 }
1558
1559 valout = 0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2];
1560 valout *= 100;
1561
1562 out( x, y, z, t ) = rescale<double,C>( valout );
1563 }
1564 }
1565
1566 template <typename C>
1567 void ChannelExtractor<AimsRGBA,C>::getChannelL( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1568 {
1569 computeRuntimeMinMax<AimsRGBA,C>( in );
1570 double valin[3];
1571 double valX, valY, valZ, valout;
1572 long dimx = in.getSizeX(),
1573 dimy = in.getSizeY(),
1574 dimz = in.getSizeZ(),
1575 dimt = in.getSizeT();
1576 for( long t=0; t< dimt; ++t )
1577 for( long z=0; z< dimz; ++z )
1578 for( long y=0; y< dimy; ++y )
1579 for( long x=0; x< dimx; ++x )
1580 {
1581 valin[0] = ((double) in( x, y, z, t ).red())/255;
1582 valin[1] = ((double) in( x, y, z, t ).green())/255;
1583 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1584
1585 for( int n=0; n<3; ++n){
1586 if( valin[n] > 0.04045 )
1587 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1588 else
1589 valin[n] = valin[n]/12.92;
1590 }
1591
1592 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1593
1594 if( valY > 0.008856 ) {
1595 valout = std::pow(valY, 0.333333);
1596 } else {
1597 valout = 7.787*valY + ((double)16/116);
1598 }
1599
1600 valout = 116*valout - 16;
1601
1602 out( x, y, z, t ) = rescale<double,C>( valout );
1603 }
1604 }
1605
1606 template <typename C>
1607 void ChannelExtractor<AimsRGBA,C>::getChannela( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1608 {
1609 computeRuntimeMinMax<AimsRGBA,C>( in );
1610 double valin[3];
1611 double valX, valY, valZ, valout;
1612 long dimx = in.getSizeX(),
1613 dimy = in.getSizeY(),
1614 dimz = in.getSizeZ(),
1615 dimt = in.getSizeT();
1616 for( long t=0; t< dimt; ++t )
1617 for( long z=0; z< dimz; ++z )
1618 for( long y=0; y< dimy; ++y )
1619 for( long x=0; x< dimx; ++x )
1620 {
1621 valin[0] = ((double) in( x, y, z, t ).red())/255;
1622 valin[1] = ((double) in( x, y, z, t ).green())/255;
1623 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1624
1625 for( int n=0; n<3; ++n){
1626 if( valin[n] > 0.04045 )
1627 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1628 else
1629 valin[n] = valin[n]/12.92;
1630 }
1631
1632 valX = (0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[2])*((double)100/95.047);
1633 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1634
1635 valout = 0.0;
1636 if( valX > 0.008856 ) {
1637 valout += std::pow(valX, 0.333333);
1638 } else {
1639 valout += 7.787*valX + ((double)16/116);
1640 }
1641 if( valY > 0.008856 ) {
1642 valout -= std::pow(valY, 0.333333);
1643 } else {
1644 valout -= 7.787*valY + ((double)16/116);
1645 }
1646 valout *= 500;
1647
1648 out( x, y, z, t ) = rescale<double,C>( valout );
1649 }
1650 }
1651
1652 template <typename C>
1653 void ChannelExtractor<AimsRGBA,C>::getChannelb( carto::VolumeRef<AimsRGBA> in, carto::VolumeRef<C> out )
1654 {
1655 computeRuntimeMinMax<AimsRGBA,C>( in );
1656 double valin[3];
1657 double valX, valY, valZ, valout;
1658 long dimx = in.getSizeX(),
1659 dimy = in.getSizeY(),
1660 dimz = in.getSizeZ(),
1661 dimt = in.getSizeT();
1662 for( long t=0; t< dimt; ++t )
1663 for( long z=0; z< dimz; ++z )
1664 for( long y=0; y< dimy; ++y )
1665 for( long x=0; x< dimx; ++x )
1666 {
1667 valin[0] = ((double) in( x, y, z, t ).red())/255;
1668 valin[1] = ((double) in( x, y, z, t ).green())/255;
1669 valin[2] = ((double) in( x, y, z, t ).blue())/255;
1670
1671 for( int n=0; n<3; ++n){
1672 if( valin[n] > 0.04045 )
1673 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
1674 else
1675 valin[n] = valin[n]/12.92;
1676 }
1677
1678 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
1679 valZ = (0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2])*((double)100/108.883);
1680
1681 valout = 0.0;
1682 if( valY > 0.008856 ) {
1683 valout += std::pow(valY, 0.333333);
1684 } else {
1685 valout += 7.787*valY + ((double)16/116);
1686 }
1687 if( valZ > 0.008856 ) {
1688 valout -= std::pow(valZ, 0.333333);
1689 } else {
1690 valout -= 7.787*valZ + ((double)16/116);
1691 }
1692 valout *= 200;
1693
1694 out( x, y, z, t ) = rescale<double,C>( valout );
1695 }
1696 }
1697
1698 //--- spec HSV -------------------------------------------------------------
1699 template <typename C>
1700 class ChannelExtractor<AimsHSV,C>: public Rescaler
1701 {
1702 public:
1703 ChannelExtractor():
1704 Rescaler()
1705 {}
1706 virtual ~ChannelExtractor() {}
1707
1708 // write in allocated volume
1709 void getChannelR( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1710 void getChannelG( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1711 void getChannelB( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1712 void getChannelRGBNorm( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1713 void getChannelYl( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1714 void getChannelCb( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1715 void getChannelCr( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1716 void getChannelH( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1717 void getChannelS( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1718 void getChannelV( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1719 void getChannelX( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1720 void getChannelY( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1721 void getChannelZ( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1722 void getChannelL( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1723 void getChannela( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1724 void getChannelb( carto::VolumeRef<AimsHSV>, carto::VolumeRef<C> );
1725
1726 // allocate and write volume
1727 carto::VolumeRef<C> getChannelR( carto::VolumeRef<AimsHSV> in )
1728 {
1729 carto::VolumeRef<C> out = allocateVolume( in );
1730 getChannelR( in, out );
1731 return out;
1732 }
1733 carto::VolumeRef<C> getChannelG( carto::VolumeRef<AimsHSV> in )
1734 {
1735 carto::VolumeRef<C> out = allocateVolume( in );
1736 getChannelG( in, out );
1737 return out;
1738 }
1739 carto::VolumeRef<C> getChannelB( carto::VolumeRef<AimsHSV> in )
1740 {
1741 carto::VolumeRef<C> out = allocateVolume( in );
1742 getChannelB( in, out );
1743 return out;
1744 }
1745 carto::VolumeRef<C> getChannelRGBNorm( carto::VolumeRef<AimsHSV> in )
1746 {
1747 carto::VolumeRef<C> out = allocateVolume( in );
1748 getChannelRGBNorm( in, out );
1749 return out;
1750 }
1751 carto::VolumeRef<C> getChannelYl( carto::VolumeRef<AimsHSV> in )
1752 {
1753 carto::VolumeRef<C> out = allocateVolume( in );
1754 getChannelYl( in, out );
1755 return out;
1756 }
1757 carto::VolumeRef<C> getChannelCb( carto::VolumeRef<AimsHSV> in )
1758 {
1759 carto::VolumeRef<C> out = allocateVolume( in );
1760 getChannelCb( in, out );
1761 return out;
1762 }
1763 carto::VolumeRef<C> getChannelCr( carto::VolumeRef<AimsHSV> in )
1764 {
1765 carto::VolumeRef<C> out = allocateVolume( in );
1766 getChannelCr( in, out );
1767 return out;
1768 }
1769 carto::VolumeRef<C> getChannelH( carto::VolumeRef<AimsHSV> in )
1770 {
1771 carto::VolumeRef<C> out = allocateVolume( in );
1772 getChannelH( in, out );
1773 return out;
1774 }
1775 carto::VolumeRef<C> getChannelS( carto::VolumeRef<AimsHSV> in )
1776 {
1777 carto::VolumeRef<C> out = allocateVolume( in );
1778 getChannelS( in, out );
1779 return out;
1780 }
1781 carto::VolumeRef<C> getChannelV( carto::VolumeRef<AimsHSV> in )
1782 {
1783 carto::VolumeRef<C> out = allocateVolume( in );
1784 getChannelV( in, out );
1785 return out;
1786 }
1787 carto::VolumeRef<C> getChannelX( carto::VolumeRef<AimsHSV> in )
1788 {
1789 carto::VolumeRef<C> out = allocateVolume( in );
1790 getChannelX( in, out );
1791 return out;
1792 }
1793 carto::VolumeRef<C> getChannelY( carto::VolumeRef<AimsHSV> in )
1794 {
1795 carto::VolumeRef<C> out = allocateVolume( in );
1796 getChannelY( in, out );
1797 return out;
1798 }
1799 carto::VolumeRef<C> getChannelZ( carto::VolumeRef<AimsHSV> in )
1800 {
1801 carto::VolumeRef<C> out = allocateVolume( in );
1802 getChannelZ( in, out );
1803 return out;
1804 }
1805 carto::VolumeRef<C> getChannelL( carto::VolumeRef<AimsHSV> in )
1806 {
1807 carto::VolumeRef<C> out = allocateVolume( in );
1808 getChannelL( in, out );
1809 return out;
1810 }
1811 carto::VolumeRef<C> getChannela( carto::VolumeRef<AimsHSV> in )
1812 {
1813 carto::VolumeRef<C> out = allocateVolume( in );
1814 getChannela( in, out );
1815 return out;
1816 }
1817 carto::VolumeRef<C> getChannelb( carto::VolumeRef<AimsHSV> in )
1818 {
1819 carto::VolumeRef<C> out = allocateVolume( in );
1820 getChannelb( in, out );
1821 return out;
1822 }
1823
1824 protected:
1825 // helper
1826 carto::VolumeRef<C> allocateVolume( carto::VolumeRef<AimsHSV> in )
1827 {
1828 carto::VolumeRef<C> out( in.getSizeX(), in.getSizeY(),
1829 in.getSizeZ(), in.getSizeT() );
1830 out->copyHeaderFrom( in.header() );
1831 return out;
1832 }
1833 };
1834
1835 template <typename C>
1836 void ChannelExtractor<AimsHSV,C>::getChannelR( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
1837 {
1838 computeRuntimeMinMax<AimsHSV,C>( in );
1839 int valH;
1840 double valS, valV, valC, valX, valM, val;
1841 long dimx = in.getSizeX(),
1842 dimy = in.getSizeY(),
1843 dimz = in.getSizeZ(),
1844 dimt = in.getSizeT();
1845 for( long t=0; t< dimt; ++t )
1846 for( long z=0; z< dimz; ++z )
1847 for( long y=0; y< dimy; ++y )
1848 for( long x=0; x< dimx; ++x ){
1849 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
1850 valS = ((double) in( x, y, z, t ).saturation())/255;
1851 valV = ((double) in( x, y, z, t ).value())/255;
1852 valC = valV*valS;
1853 valX = valC*(1-abs((valH/60)%2-1));
1854 valM = valV-valC;
1855
1856 if (valH<120 || valH>=240){
1857 if(60<=valH<300){
1858 val = valX;
1859 }else{
1860 val = valC;
1861 }
1862 }
1863
1864 val += valM;
1865 val *= 255;
1866 out( x, y, z, t ) = rescale<double,C>( val );
1867 }
1868 }
1869
1870 template <typename C>
1871 void ChannelExtractor<AimsHSV,C>::getChannelG( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
1872 {
1873 computeRuntimeMinMax<AimsHSV,C>( in );
1874 int valH;
1875 double valS, valV, valC, valX, valM, val;
1876 long dimx = in.getSizeX(),
1877 dimy = in.getSizeY(),
1878 dimz = in.getSizeZ(),
1879 dimt = in.getSizeT();
1880 for( long t=0; t< dimt; ++t )
1881 for( long z=0; z< dimz; ++z )
1882 for( long y=0; y< dimy; ++y )
1883 for( long x=0; x< dimx; ++x ){
1884 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
1885 valS = ((double) in( x, y, z, t ).saturation())/255;
1886 valV = ((double) in( x, y, z, t ).value())/255;
1887 valC = valV*valS;
1888 valX = valC*(1-abs((valH/60)%2-1));
1889 valM = valV-valC;
1890
1891 if (valH<240){
1892 if(60<=valH<180){
1893 val = valC;
1894 }else{
1895 val = valX;
1896 }
1897 }
1898
1899 val += valM;
1900 val *= 255;
1901 out( x, y, z, t ) = rescale<double,C>( val );
1902 }
1903 }
1904
1905 template <typename C>
1906 void ChannelExtractor<AimsHSV,C>::getChannelB( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
1907 {
1908 computeRuntimeMinMax<AimsHSV,C>( in );
1909 int valH;
1910 double valS, valV, valC, valX, valM, val;
1911 long dimx = in.getSizeX(),
1912 dimy = in.getSizeY(),
1913 dimz = in.getSizeZ(),
1914 dimt = in.getSizeT();
1915 for( long t=0; t< dimt; ++t )
1916 for( long z=0; z< dimz; ++z )
1917 for( long y=0; y< dimy; ++y )
1918 for( long x=0; x< dimx; ++x ){
1919 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
1920 valS = ((double) in( x, y, z, t ).saturation())/255;
1921 valV = ((double) in( x, y, z, t ).value())/255;
1922 valC = valV*valS;
1923 valX = valC*(1-abs((valH/60)%2-1));
1924 valM = valV-valC;
1925
1926 if (valH>=120){
1927 if(180<=valH<300){
1928 val = valC;
1929 }else{
1930 val = valX;
1931 }
1932 }
1933
1934 val += valM;
1935 val *= 255;
1936 out( x, y, z, t ) = rescale<double,C>( val );
1937 }
1938 }
1939
1940 template <typename C>
1941 void ChannelExtractor<AimsHSV,C>::getChannelRGBNorm( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
1942 {
1943 computeRuntimeMinMax<AimsHSV,C>( in );
1944 int valH;
1945 double valS, valV, valC, valX, valM, valR, valG, valB, val;
1946 long dimx = in.getSizeX(),
1947 dimy = in.getSizeY(),
1948 dimz = in.getSizeZ(),
1949 dimt = in.getSizeT();
1950 for( long t=0; t< dimt; ++t )
1951 for( long z=0; z< dimz; ++z )
1952 for( long y=0; y< dimy; ++y )
1953 for( long x=0; x< dimx; ++x ){
1954 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
1955 valS = ((double) in( x, y, z, t ).saturation())/255;
1956 valV = ((double) in( x, y, z, t ).value())/255;
1957 valC = valV*valS;
1958 valX = valC*(1-abs((valH/60)%2-1));
1959 valM = valV-valC;
1960
1961 if (valH<120 || valH>=240){
1962 if(60<=valH<300){
1963 valR = valX;
1964 }else{
1965 valR = valC;
1966 }
1967 }
1968
1969 valR += valM;
1970 valR *= 255;
1971
1972 if (valH<240){
1973 if(60<=valH<180){
1974 valG = valC;
1975 }else{
1976 valG = valX;
1977 }
1978 }
1979
1980 valG += valM;
1981 valG *= 255;
1982
1983 if (valH>=120){
1984 if(180<=valH<300){
1985 valB = valC;
1986 }else{
1987 valB = valX;
1988 }
1989 }
1990
1991 valB += valM;
1992 valB *= 255;
1993
1994 val = valR + valG + valB;
1995 val /= 3;
1996 out( x, y, z, t ) = rescale<double,C>( val );
1997 }
1998 }
1999
2000 template <typename C>
2001 void ChannelExtractor<AimsHSV,C>::getChannelYl( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2002 {
2003 computeRuntimeMinMax<AimsHSV,C>( in );
2004 int valH;
2005 double valS, valV, valC, valX, valM, valR, valG, valB, val;
2006 long dimx = in.getSizeX(),
2007 dimy = in.getSizeY(),
2008 dimz = in.getSizeZ(),
2009 dimt = in.getSizeT();
2010 for( long t=0; t< dimt; ++t )
2011 for( long z=0; z< dimz; ++z )
2012 for( long y=0; y< dimy; ++y )
2013 for( long x=0; x< dimx; ++x ){
2014 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2015 valS = ((double) in( x, y, z, t ).saturation())/255;
2016 valV = ((double) in( x, y, z, t ).value())/255;
2017 valC = valV*valS;
2018 valX = valC*(1-abs((valH/60)%2-1));
2019 valM = valV-valC;
2020
2021 if (valH<120 || valH>=240){
2022 if(60<=valH<300){
2023 valR = valX;
2024 }else{
2025 valR = valC;
2026 }
2027 }
2028
2029 valR += valM;
2030 valR *= 255;
2031
2032 if (valH<240){
2033 if(60<=valH<180){
2034 valG = valC;
2035 }else{
2036 valG = valX;
2037 }
2038 }
2039
2040 valG += valM;
2041 valG *= 255;
2042
2043 if (valH>=120){
2044 if(180<=valH<300){
2045 valB = valC;
2046 }else{
2047 valB = valX;
2048 }
2049 }
2050
2051 valB += valM;
2052 valB *= 255;
2053
2054 val = 0.299 * valR + 0.587 * valG + 0.114 * valB;
2055 out( x, y, z, t ) = rescale<double,C>( val );
2056 }
2057 }
2058
2059 template <typename C>
2060 void ChannelExtractor<AimsHSV,C>::getChannelCb( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2061 {
2062 computeRuntimeMinMax<AimsHSV,C>( in );
2063 int valH;
2064 double valS, valV, valC, valX, valM, valR, valG, valB, val;
2065 long dimx = in.getSizeX(),
2066 dimy = in.getSizeY(),
2067 dimz = in.getSizeZ(),
2068 dimt = in.getSizeT();
2069 for( long t=0; t< dimt; ++t )
2070 for( long z=0; z< dimz; ++z )
2071 for( long y=0; y< dimy; ++y )
2072 for( long x=0; x< dimx; ++x ){
2073 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2074 valS = ((double) in( x, y, z, t ).saturation())/255;
2075 valV = ((double) in( x, y, z, t ).value())/255;
2076 valC = valV*valS;
2077 valX = valC*(1-abs((valH/60)%2-1));
2078 valM = valV-valC;
2079
2080 if (valH<120 || valH>=240){
2081 if(60<=valH<300){
2082 valR = valX;
2083 }else{
2084 valR = valC;
2085 }
2086 }
2087
2088 valR += valM;
2089 valR *= 255;
2090
2091 if (valH<240){
2092 if(60<=valH<180){
2093 valG = valC;
2094 }else{
2095 valG = valX;
2096 }
2097 }
2098
2099 valG += valM;
2100 valG *= 255;
2101
2102 if (valH>=120){
2103 if(180<=valH<300){
2104 valB = valC;
2105 }else{
2106 valB = valX;
2107 }
2108 }
2109
2110 valB += valM;
2111 valB *= 255;
2112
2113 val = - 0.1687 * valR - 0.3313 * valG + 0.5 * valB + 128;
2114 out( x, y, z, t ) = rescale<double,C>( val );
2115 }
2116 }
2117
2118 template <typename C>
2119 void ChannelExtractor<AimsHSV,C>::getChannelCr( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2120 {
2121 computeRuntimeMinMax<AimsHSV,C>( in );
2122 int valH;
2123 double valS, valV, valC, valX, valM, valR, valG, valB, val;
2124 long dimx = in.getSizeX(),
2125 dimy = in.getSizeY(),
2126 dimz = in.getSizeZ(),
2127 dimt = in.getSizeT();
2128 for( long t=0; t< dimt; ++t )
2129 for( long z=0; z< dimz; ++z )
2130 for( long y=0; y< dimy; ++y )
2131 for( long x=0; x< dimx; ++x ){
2132 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2133 valS = ((double) in( x, y, z, t ).saturation())/255;
2134 valV = ((double) in( x, y, z, t ).value())/255;
2135 valC = valV*valS;
2136 valX = valC*(1-abs((valH/60)%2-1));
2137 valM = valV-valC;
2138
2139 if (valH<120 || valH>=240){
2140 if(60<=valH<300){
2141 valR = valX;
2142 }else{
2143 valR = valC;
2144 }
2145 }
2146
2147 valR += valM;
2148 valR *= 255;
2149
2150 if (valH<240){
2151 if(60<=valH<180){
2152 valG = valC;
2153 }else{
2154 valG = valX;
2155 }
2156 }
2157
2158 valG += valM;
2159 valG *= 255;
2160
2161 if (valH>=120){
2162 if(180<=valH<300){
2163 valB = valC;
2164 }else{
2165 valB = valX;
2166 }
2167 }
2168
2169 valB += valM;
2170 valB *= 255;
2171
2172 val = 0.5 * valR - 0.4187 * valG - 0.0813 * valB + 128;
2173 out( x, y, z, t ) = rescale<double,C>( val );
2174 }
2175 }
2176
2177 template <typename C>
2178 void ChannelExtractor<AimsHSV,C>::getChannelH( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2179 {
2180 computeRuntimeMinMax<AimsHSV,C>( in, 0 );
2181
2182 long dimx = in.getSizeX(),
2183 dimy = in.getSizeY(),
2184 dimz = in.getSizeZ(),
2185 dimt = in.getSizeT();
2186 for( long t=0; t< dimt; ++t )
2187 for( long z=0; z< dimz; ++z )
2188 for( long y=0; y< dimy; ++y )
2189 for( long x=0; x< dimx; ++x )
2190 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsHSV>::ChannelType,C>( in( x, y, z, t ).hue() );
2191 }
2192
2193 template <typename C>
2194 void ChannelExtractor<AimsHSV,C>::getChannelS( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2195 {
2196 computeRuntimeMinMax<AimsHSV,C>( in, 1 );
2197
2198 long dimx = in.getSizeX(),
2199 dimy = in.getSizeY(),
2200 dimz = in.getSizeZ(),
2201 dimt = in.getSizeT();
2202 for( long t=0; t< dimt; ++t )
2203 for( long z=0; z< dimz; ++z )
2204 for( long y=0; y< dimy; ++y )
2205 for( long x=0; x< dimx; ++x )
2206 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsHSV>::ChannelType,C>( in( x, y, z, t ).saturation() );
2207 }
2208
2209 template <typename C>
2210 void ChannelExtractor<AimsHSV,C>::getChannelV( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2211 {
2212 computeRuntimeMinMax<AimsHSV,C>( in, 2 );
2213
2214 long dimx = in.getSizeX(),
2215 dimy = in.getSizeY(),
2216 dimz = in.getSizeZ(),
2217 dimt = in.getSizeT();
2218 for( long t=0; t< dimt; ++t )
2219 for( long z=0; z< dimz; ++z )
2220 for( long y=0; y< dimy; ++y )
2221 for( long x=0; x< dimx; ++x )
2222 out( x, y, z, t ) = rescale<carto::DataTypeTraits<AimsHSV>::ChannelType,C>( in( x, y, z, t ).value() );
2223 }
2224
2225 template <typename C>
2226 void ChannelExtractor<AimsHSV,C>::getChannelX( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2227 {
2228 computeRuntimeMinMax<AimsHSV,C>( in );
2229 int valH;
2230 double valS, valV, valC, valX, valM, valout;
2231 double valin[3];
2232 long dimx = in.getSizeX(),
2233 dimy = in.getSizeY(),
2234 dimz = in.getSizeZ(),
2235 dimt = in.getSizeT();
2236 for( long t=0; t< dimt; ++t )
2237 for( long z=0; z< dimz; ++z )
2238 for( long y=0; y< dimy; ++y )
2239 for( long x=0; x< dimx; ++x )
2240 {
2241 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2242 valS = ((double) in( x, y, z, t ).saturation())/255;
2243 valV = ((double) in( x, y, z, t ).value())/255;
2244 valC = valV*valS;
2245 valX = valC*(1-abs((valH/60)%2-1));
2246 valM = valV-valC;
2247
2248 if (valH<120 || valH>=240){
2249 if(60<=valH<300){
2250 valin[0] = valX;
2251 }else{
2252 valin[0] = valC;
2253 }
2254 }
2255
2256 valin[0] += valM;
2257
2258 if (valH<240){
2259 if(60<=valH<180){
2260 valin[1] = valC;
2261 }else{
2262 valin[1] = valX;
2263 }
2264 }
2265
2266 valin[1] += valM;
2267
2268 if (valH>=120){
2269 if(180<=valH<300){
2270 valin[2] = valC;
2271 }else{
2272 valin[2] = valX;
2273 }
2274 }
2275
2276 valin[2] += valM;
2277
2278 valout = 0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[1];
2279 valout *= 100;
2280
2281 out( x, y, z, t ) = rescale<double,C>( valout );
2282 }
2283 }
2284
2285 template <typename C>
2286 void ChannelExtractor<AimsHSV,C>::getChannelY( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2287 {
2288 computeRuntimeMinMax<AimsHSV,C>( in );
2289 int valH;
2290 double valS, valV, valC, valX, valM, valout;
2291 double valin[3];
2292 long dimx = in.getSizeX(),
2293 dimy = in.getSizeY(),
2294 dimz = in.getSizeZ(),
2295 dimt = in.getSizeT();
2296 for( long t=0; t< dimt; ++t )
2297 for( long z=0; z< dimz; ++z )
2298 for( long y=0; y< dimy; ++y )
2299 for( long x=0; x< dimx; ++x )
2300 {
2301 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2302 valS = ((double) in( x, y, z, t ).saturation())/255;
2303 valV = ((double) in( x, y, z, t ).value())/255;
2304 valC = valV*valS;
2305 valX = valC*(1-abs((valH/60)%2-1));
2306 valM = valV-valC;
2307
2308 if (valH<120 || valH>=240){
2309 if(60<=valH<300){
2310 valin[0] = valX;
2311 }else{
2312 valin[0] = valC;
2313 }
2314 }
2315
2316 valin[0] += valM;
2317
2318 if (valH<240){
2319 if(60<=valH<180){
2320 valin[1] = valC;
2321 }else{
2322 valin[1] = valX;
2323 }
2324 }
2325
2326 valin[1] += valM;
2327
2328 if (valH>=120){
2329 if(180<=valH<300){
2330 valin[2] = valC;
2331 }else{
2332 valin[2] = valX;
2333 }
2334 }
2335
2336 valin[2] += valM;
2337
2338 valout = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
2339 valout *= 100;
2340
2341 out( x, y, z, t ) = rescale<double,C>( valout );
2342 }
2343 }
2344
2345 template <typename C>
2346 void ChannelExtractor<AimsHSV,C>::getChannelZ( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2347 {
2348 computeRuntimeMinMax<AimsHSV,C>( in );
2349 int valH;
2350 double valS, valV, valC, valX, valM, valout;
2351 double valin[3];
2352 long dimx = in.getSizeX(),
2353 dimy = in.getSizeY(),
2354 dimz = in.getSizeZ(),
2355 dimt = in.getSizeT();
2356 for( long t=0; t< dimt; ++t )
2357 for( long z=0; z< dimz; ++z )
2358 for( long y=0; y< dimy; ++y )
2359 for( long x=0; x< dimx; ++x )
2360 {
2361 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2362 valS = ((double) in( x, y, z, t ).saturation())/255;
2363 valV = ((double) in( x, y, z, t ).value())/255;
2364 valC = valV*valS;
2365 valX = valC*(1-abs((valH/60)%2-1));
2366 valM = valV-valC;
2367
2368 if (valH<120 || valH>=240){
2369 if(60<=valH<300){
2370 valin[0] = valX;
2371 }else{
2372 valin[0] = valC;
2373 }
2374 }
2375
2376 valin[0] += valM;
2377
2378 if (valH<240){
2379 if(60<=valH<180){
2380 valin[1] = valC;
2381 }else{
2382 valin[1] = valX;
2383 }
2384 }
2385
2386 valin[1] += valM;
2387
2388 if (valH>=120){
2389 if(180<=valH<300){
2390 valin[2] = valC;
2391 }else{
2392 valin[2] = valX;
2393 }
2394 }
2395
2396 valin[2] += valM;
2397
2398 valout = 0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2];
2399 valout *= 100;
2400
2401 out( x, y, z, t ) = rescale<double,C>( valout );
2402 }
2403 }
2404
2405 template <typename C>
2406 void ChannelExtractor<AimsHSV,C>::getChannelL( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2407 {
2408 computeRuntimeMinMax<AimsHSV,C>( in );
2409 int valH;
2410 double valS, valV, valC, valX, valY, valM, valout;
2411 double valin[3];
2412 long dimx = in.getSizeX(),
2413 dimy = in.getSizeY(),
2414 dimz = in.getSizeZ(),
2415 dimt = in.getSizeT();
2416 for( long t=0; t< dimt; ++t )
2417 for( long z=0; z< dimz; ++z )
2418 for( long y=0; y< dimy; ++y )
2419 for( long x=0; x< dimx; ++x )
2420 {
2421 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2422 valS = ((double) in( x, y, z, t ).saturation())/255;
2423 valV = ((double) in( x, y, z, t ).value())/255;
2424 valC = valV*valS;
2425 valX = valC*(1-abs((valH/60)%2-1));
2426 valM = valV-valC;
2427
2428 if (valH<120 || valH>=240){
2429 if(60<=valH<300){
2430 valin[0] = valX;
2431 }else{
2432 valin[0] = valC;
2433 }
2434 }
2435
2436 valin[0] += valM;
2437
2438 if (valH<240){
2439 if(60<=valH<180){
2440 valin[1] = valC;
2441 }else{
2442 valin[1] = valX;
2443 }
2444 }
2445
2446 valin[1] += valM;
2447
2448 if (valH>=120){
2449 if(180<=valH<300){
2450 valin[2] = valC;
2451 }else{
2452 valin[2] = valX;
2453 }
2454 }
2455
2456 valin[2] += valM;
2457
2458 for( int n=0; n<3; ++n){
2459 if( valin[n] > 0.04045 )
2460 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
2461 else
2462 valin[n] = valin[n]/12.92;
2463 }
2464
2465 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
2466
2467 if( valY > 0.008856 ) {
2468 valout = std::pow(valY, 0.333333);
2469 } else {
2470 valout = 7.787*valY + ((double)16/116);
2471 }
2472
2473 valout = 116*valout - 16;
2474
2475 out( x, y, z, t ) = rescale<double,C>( valout );
2476 }
2477 }
2478
2479 template <typename C>
2480 void ChannelExtractor<AimsHSV,C>::getChannela( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2481 {
2482 computeRuntimeMinMax<AimsHSV,C>( in );
2483 int valH;
2484 double valS, valV, valC, valX, valY, valM, valout;
2485 double valin[3];
2486 long dimx = in.getSizeX(),
2487 dimy = in.getSizeY(),
2488 dimz = in.getSizeZ(),
2489 dimt = in.getSizeT();
2490 for( long t=0; t< dimt; ++t )
2491 for( long z=0; z< dimz; ++z )
2492 for( long y=0; y< dimy; ++y )
2493 for( long x=0; x< dimx; ++x )
2494 {
2495 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2496 valS = ((double) in( x, y, z, t ).saturation())/255;
2497 valV = ((double) in( x, y, z, t ).value())/255;
2498 valC = valV*valS;
2499 valX = valC*(1-abs((valH/60)%2-1));
2500 valM = valV-valC;
2501
2502 if (valH<120 || valH>=240){
2503 if(60<=valH<300){
2504 valin[0] = valX;
2505 }else{
2506 valin[0] = valC;
2507 }
2508 }
2509
2510 valin[0] += valM;
2511
2512 if (valH<240){
2513 if(60<=valH<180){
2514 valin[1] = valC;
2515 }else{
2516 valin[1] = valX;
2517 }
2518 }
2519
2520 valin[1] += valM;
2521
2522 if (valH>=120){
2523 if(180<=valH<300){
2524 valin[2] = valC;
2525 }else{
2526 valin[2] = valX;
2527 }
2528 }
2529
2530 valin[2] += valM;
2531
2532 for( int n=0; n<3; ++n){
2533 if( valin[n] > 0.04045 )
2534 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
2535 else
2536 valin[n] = valin[n]/12.92;
2537 }
2538
2539 valX = (0.412453*valin[0] + 0.357580*valin[1] + 0.180423*valin[2])*((double)100/95.047);
2540 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
2541
2542 valout = 0.0;
2543 if( valX > 0.008856 ) {
2544 valout += std::pow(valX, 0.333333);
2545 } else {
2546 valout += 7.787*valX + ((double)16/116);
2547 }
2548 if( valY > 0.008856 ) {
2549 valout -= std::pow(valY, 0.333333);
2550 } else {
2551 valout -= 7.787*valY + ((double)16/116);
2552 }
2553 valout *= 500;
2554
2555 out( x, y, z, t ) = rescale<double,C>( valout );
2556 }
2557 }
2558
2559 template <typename C>
2560 void ChannelExtractor<AimsHSV,C>::getChannelb( carto::VolumeRef<AimsHSV> in, carto::VolumeRef<C> out )
2561 {
2562 computeRuntimeMinMax<AimsHSV,C>( in );
2563 int valH;
2564 double valS, valV, valC, valX, valY, valZ, valM, valout;
2565 double valin[3];
2566 long dimx = in.getSizeX(),
2567 dimy = in.getSizeY(),
2568 dimz = in.getSizeZ(),
2569 dimt = in.getSizeT();
2570 for( long t=0; t< dimt; ++t )
2571 for( long z=0; z< dimz; ++z )
2572 for( long y=0; y< dimy; ++y )
2573 for( long x=0; x< dimx; ++x )
2574 {
2575 valH = (int) (((double) in( x, y, z, t ).hue())/255)*360;
2576 valS = ((double) in( x, y, z, t ).saturation())/255;
2577 valV = ((double) in( x, y, z, t ).value())/255;
2578 valC = valV*valS;
2579 valX = valC*(1-abs((valH/60)%2-1));
2580 valM = valV-valC;
2581
2582 if (valH<120 || valH>=240){
2583 if(60<=valH<300){
2584 valin[0] = valX;
2585 }else{
2586 valin[0] = valC;
2587 }
2588 }
2589
2590 valin[0] += valM;
2591
2592 if (valH<240){
2593 if(60<=valH<180){
2594 valin[1] = valC;
2595 }else{
2596 valin[1] = valX;
2597 }
2598 }
2599
2600 valin[1] += valM;
2601
2602 if (valH>=120){
2603 if(180<=valH<300){
2604 valin[2] = valC;
2605 }else{
2606 valin[2] = valX;
2607 }
2608 }
2609
2610 valin[2] += valM;
2611
2612 for( int n=0; n<3; ++n){
2613 if( valin[n] > 0.04045 )
2614 valin[n] = std::pow((valin[n] + 0.055)/(1 + 0.055), 2.4);
2615 else
2616 valin[n] = valin[n]/12.92;
2617 }
2618
2619 valY = 0.212671*valin[0] + 0.715160*valin[1] + 0.072169*valin[2];
2620 valZ = (0.019334*valin[0] + 0.119193*valin[1] + 0.950227*valin[2])*((double)100/108.883);
2621
2622 valout = 0.0;
2623 if( valY > 0.008856 ) {
2624 valout += std::pow(valY, 0.333333);
2625 } else {
2626 valout += 7.787*valY + ((double)16/116);
2627 }
2628 if( valZ > 0.008856 ) {
2629 valout -= std::pow(valZ, 0.333333);
2630 } else {
2631 valout -= 7.787*valZ + ((double)16/116);
2632 }
2633 valout *= 200;
2634
2635 out( x, y, z, t ) = rescale<double,C>( valout );
2636 }
2637 }
2638
2639} // namespace bio
2640
2641#endif // BRAINRAT_UTILITY_CHANNELEXTRACTOR_H
bio::ChannelExtractor::not_impl_exception
Definition channelextractor.h:343
bio::ChannelExtractor::not_impl_exception::what
virtual const char * what() const
Definition channelextractor.h:347
bio::ChannelExtractor::not_impl_exception::~not_impl_exception
virtual ~not_impl_exception()
Definition channelextractor.h:346
bio::ChannelExtractor::not_impl_exception::not_impl_exception
not_impl_exception()
Definition channelextractor.h:345
bio::ChannelExtractor< AimsHSV, C >::getChannelb
carto::VolumeRef< C > getChannelb(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1817
bio::ChannelExtractor< AimsHSV, C >::getChannelY
carto::VolumeRef< C > getChannelY(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1793
bio::ChannelExtractor< AimsHSV, C >::getChannelYl
carto::VolumeRef< C > getChannelYl(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1751
bio::ChannelExtractor< AimsHSV, C >::getChannela
carto::VolumeRef< C > getChannela(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1811
bio::ChannelExtractor< AimsHSV, C >::getChannelCr
carto::VolumeRef< C > getChannelCr(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1763
bio::ChannelExtractor< AimsHSV, C >::allocateVolume
carto::VolumeRef< C > allocateVolume(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1826
bio::ChannelExtractor< AimsHSV, C >::getChannelCb
carto::VolumeRef< C > getChannelCb(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1757
bio::ChannelExtractor< AimsHSV, C >::getChannelR
carto::VolumeRef< C > getChannelR(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1727
bio::ChannelExtractor< AimsHSV, C >::getChannelB
carto::VolumeRef< C > getChannelB(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1739
bio::ChannelExtractor< AimsHSV, C >::getChannelL
carto::VolumeRef< C > getChannelL(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1805
bio::ChannelExtractor< AimsHSV, C >::getChannelV
carto::VolumeRef< C > getChannelV(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1781
bio::ChannelExtractor< AimsHSV, C >::getChannelX
carto::VolumeRef< C > getChannelX(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1787
bio::ChannelExtractor< AimsHSV, C >::getChannelZ
carto::VolumeRef< C > getChannelZ(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1799
bio::ChannelExtractor< AimsHSV, C >::getChannelG
carto::VolumeRef< C > getChannelG(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1733
bio::ChannelExtractor< AimsHSV, C >::getChannelRGBNorm
carto::VolumeRef< C > getChannelRGBNorm(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1745
bio::ChannelExtractor< AimsHSV, C >::getChannelH
carto::VolumeRef< C > getChannelH(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1769
bio::ChannelExtractor< AimsHSV, C >::getChannelS
carto::VolumeRef< C > getChannelS(carto::VolumeRef< AimsHSV > in)
Definition channelextractor.h:1775
bio::ChannelExtractor< AimsRGBA, C >::getChannelG
carto::VolumeRef< C > getChannelG(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1107
bio::ChannelExtractor< AimsRGBA, C >::getChannelY
carto::VolumeRef< C > getChannelY(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1173
bio::ChannelExtractor< AimsRGBA, C >::getChannelR
carto::VolumeRef< C > getChannelR(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1101
bio::ChannelExtractor< AimsRGBA, C >::getChannelb
carto::VolumeRef< C > getChannelb(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1197
bio::ChannelExtractor< AimsRGBA, C >::getChannela
carto::VolumeRef< C > getChannela(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1191
bio::ChannelExtractor< AimsRGBA, C >::getChannelCr
carto::VolumeRef< C > getChannelCr(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1143
bio::ChannelExtractor< AimsRGBA, C >::getChannelB
carto::VolumeRef< C > getChannelB(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1113
bio::ChannelExtractor< AimsRGBA, C >::getChannelCb
carto::VolumeRef< C > getChannelCb(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1137
bio::ChannelExtractor< AimsRGBA, C >::getChannelYl
carto::VolumeRef< C > getChannelYl(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1131
bio::ChannelExtractor< AimsRGBA, C >::getChannelZ
carto::VolumeRef< C > getChannelZ(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1179
bio::ChannelExtractor< AimsRGBA, C >::allocateVolume
carto::VolumeRef< C > allocateVolume(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1206
bio::ChannelExtractor< AimsRGBA, C >::getChannelV
carto::VolumeRef< C > getChannelV(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1161
bio::ChannelExtractor< AimsRGBA, C >::getChannelX
carto::VolumeRef< C > getChannelX(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1167
bio::ChannelExtractor< AimsRGBA, C >::getChannelL
carto::VolumeRef< C > getChannelL(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1185
bio::ChannelExtractor< AimsRGBA, C >::getChannelS
carto::VolumeRef< C > getChannelS(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1155
bio::ChannelExtractor< AimsRGBA, C >::getChannelH
carto::VolumeRef< C > getChannelH(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1149
bio::ChannelExtractor< AimsRGBA, C >::getChannelRGBNorm
carto::VolumeRef< C > getChannelRGBNorm(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1125
bio::ChannelExtractor< AimsRGBA, C >::getChannelA
void getChannelA(carto::VolumeRef< AimsRGBA >, carto::VolumeRef< C >)
Definition channelextractor.h:1264
bio::ChannelExtractor< AimsRGBA, C >::getChannelA
carto::VolumeRef< C > getChannelA(carto::VolumeRef< AimsRGBA > in)
Definition channelextractor.h:1119
bio::ChannelExtractor< AimsRGB, C >::getChannelL
carto::VolumeRef< C > getChannelL(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:589
bio::ChannelExtractor< AimsRGB, C >::getChannelCb
carto::VolumeRef< C > getChannelCb(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:541
bio::ChannelExtractor< AimsRGB, C >::getChannelR
carto::VolumeRef< C > getChannelR(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:511
bio::ChannelExtractor< AimsRGB, C >::getChannelZ
carto::VolumeRef< C > getChannelZ(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:583
bio::ChannelExtractor< AimsRGB, C >::allocateVolume
carto::VolumeRef< C > allocateVolume(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:610
bio::ChannelExtractor< AimsRGB, C >::getChannelH
carto::VolumeRef< C > getChannelH(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:553
bio::ChannelExtractor< AimsRGB, C >::getChannelb
carto::VolumeRef< C > getChannelb(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:601
bio::ChannelExtractor< AimsRGB, C >::getChannelRGBNorm
carto::VolumeRef< C > getChannelRGBNorm(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:529
bio::ChannelExtractor< AimsRGB, C >::getChannelY
carto::VolumeRef< C > getChannelY(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:577
bio::ChannelExtractor< AimsRGB, C >::getChannelB
carto::VolumeRef< C > getChannelB(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:523
bio::ChannelExtractor< AimsRGB, C >::getChannelG
carto::VolumeRef< C > getChannelG(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:517
bio::ChannelExtractor< AimsRGB, C >::getChannelX
carto::VolumeRef< C > getChannelX(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:571
bio::ChannelExtractor< AimsRGB, C >::getChannelCr
carto::VolumeRef< C > getChannelCr(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:547
bio::ChannelExtractor< AimsRGB, C >::getChannelS
carto::VolumeRef< C > getChannelS(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:559
bio::ChannelExtractor< AimsRGB, C >::getChannela
carto::VolumeRef< C > getChannela(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:595
bio::ChannelExtractor< AimsRGB, C >::getChannelV
carto::VolumeRef< C > getChannelV(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:565
bio::ChannelExtractor< AimsRGB, C >::getChannelYl
carto::VolumeRef< C > getChannelYl(carto::VolumeRef< AimsRGB > in)
Definition channelextractor.h:535
bio::ChannelExtractor::getChannelX
carto::VolumeRef< C > getChannelX(carto::VolumeRef< T > in)
Definition channelextractor.h:433
bio::ChannelExtractor::getChannelb
void getChannelb(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:370
bio::ChannelExtractor::getChannelY
void getChannelY(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:366
bio::ChannelExtractor::getChannelZ
void getChannelZ(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:367
bio::ChannelExtractor::getChannelH
carto::VolumeRef< C > getChannelH(carto::VolumeRef< T > in)
Definition channelextractor.h:415
bio::ChannelExtractor::getChannelR
carto::VolumeRef< C > getChannelR(carto::VolumeRef< T > in)
Definition channelextractor.h:373
bio::ChannelExtractor::getChannelYl
carto::VolumeRef< C > getChannelYl(carto::VolumeRef< T > in)
Definition channelextractor.h:397
bio::ChannelExtractor::getChannela
void getChannela(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:369
bio::ChannelExtractor::getChannelH
void getChannelH(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:362
bio::ChannelExtractor::getChannelG
carto::VolumeRef< C > getChannelG(carto::VolumeRef< T > in)
Definition channelextractor.h:379
bio::ChannelExtractor::getChannelB
void getChannelB(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:357
bio::ChannelExtractor::getChannelV
void getChannelV(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:364
bio::ChannelExtractor::getChannelZ
carto::VolumeRef< C > getChannelZ(carto::VolumeRef< T > in)
Definition channelextractor.h:445
bio::ChannelExtractor::getChannelb
carto::VolumeRef< C > getChannelb(carto::VolumeRef< T > in)
Definition channelextractor.h:463
bio::ChannelExtractor::getChannelCb
void getChannelCb(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:360
bio::ChannelExtractor::getChannelRGBNorm
void getChannelRGBNorm(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:358
bio::ChannelExtractor::getChannela
carto::VolumeRef< C > getChannela(carto::VolumeRef< T > in)
Definition channelextractor.h:457
bio::ChannelExtractor::getChannelL
void getChannelL(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:368
bio::ChannelExtractor::getChannelCr
carto::VolumeRef< C > getChannelCr(carto::VolumeRef< T > in)
Definition channelextractor.h:409
bio::ChannelExtractor::getChannelYl
void getChannelYl(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:359
bio::ChannelExtractor::getChannelL
carto::VolumeRef< C > getChannelL(carto::VolumeRef< T > in)
Definition channelextractor.h:451
bio::ChannelExtractor::getChannelS
void getChannelS(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:363
bio::ChannelExtractor::getChannelY
carto::VolumeRef< C > getChannelY(carto::VolumeRef< T > in)
Definition channelextractor.h:439
bio::ChannelExtractor::getChannelS
carto::VolumeRef< C > getChannelS(carto::VolumeRef< T > in)
Definition channelextractor.h:421
bio::ChannelExtractor::getChannelR
void getChannelR(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:355
bio::ChannelExtractor::allocateVolume
carto::VolumeRef< C > allocateVolume(carto::VolumeRef< T > in)
Definition channelextractor.h:472
bio::ChannelExtractor::getChannelCb
carto::VolumeRef< C > getChannelCb(carto::VolumeRef< T > in)
Definition channelextractor.h:403
bio::ChannelExtractor::getChannelB
carto::VolumeRef< C > getChannelB(carto::VolumeRef< T > in)
Definition channelextractor.h:385
bio::ChannelExtractor::getChannelV
carto::VolumeRef< C > getChannelV(carto::VolumeRef< T > in)
Definition channelextractor.h:427
bio::ChannelExtractor::getChannelG
void getChannelG(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:356
bio::ChannelExtractor::getChannelX
void getChannelX(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:365
bio::ChannelExtractor::getChannelCr
void getChannelCr(carto::VolumeRef< T >, carto::VolumeRef< C >)
Definition channelextractor.h:361
bio::ChannelExtractor::getChannelRGBNorm
carto::VolumeRef< C > getChannelRGBNorm(carto::VolumeRef< T > in)
Definition channelextractor.h:391
bio::Rescaler::bad_options_exception
Definition channelextractor.h:70
bio::Rescaler::bad_options_exception::what
virtual const char * what() const
Definition channelextractor.h:74
bio::Rescaler::bad_options_exception::~bad_options_exception
virtual ~bad_options_exception()
Definition channelextractor.h:73
bio::Rescaler::bad_options_exception::bad_options_exception
bad_options_exception()
Definition channelextractor.h:72
bio::Rescaler::setOutputMax
void setOutputMax(double val)
Definition channelextractor.h:103
bio::Rescaler::setInputDynMinMax
void setInputDynMinMax(bool val=true)
Definition channelextractor.h:108
bio::Rescaler::computeInputDynMax
void computeInputDynMax(carto::VolumeRef< T > in, int ch=0)
Definition channelextractor.h:139
bio::Rescaler::computeRuntimeMinMax
void computeRuntimeMinMax(carto::VolumeRef< T > in, int ch=0)
Definition channelextractor.h:173
bio::Rescaler::setOutputMin
void setOutputMin(double val)
Definition channelextractor.h:102
bio::Rescaler::~Rescaler
virtual ~Rescaler()
Definition channelextractor.h:63
bio::Rescaler::computeInputDynMin
void computeInputDynMin(carto::VolumeRef< T > in, int ch=0)
Definition channelextractor.h:134
bio::Rescaler::setInputMax
void setInputMax(double val)
Definition channelextractor.h:101
bio::Rescaler::setInputDynMinMax
void setInputDynMinMax(carto::VolumeRef< T > in)
Definition channelextractor.h:110
bio::Rescaler::setRescale
void setRescale(bool val=true)
Definition channelextractor.h:99
bio::Rescaler::setInputMin
void setInputMin(double val)
Definition channelextractor.h:100
bio
ImageProcessors<AimsRGB, double> p(data, mask, "rgbm", options, ImageProcessorMode::Init); ImageProce...
Definition classes.h:25
rescale
void rescale(carto::VolumeRef< T > &in, carto::RescalerInfo &info)