<div dir="ltr">Sorry for disturbance,<div>but I have </div><div>ImageType::Pointer image_1 = reader-&gt;GetOutput() ;</div><div><br></div><div>I misunderstand how to get the pixel type of  image_1 , using the 2 options you gave me . could u give me more details </div>
<div><br></div><div>Best regards <br><br><div class="gmail_quote">On Tue, Dec 28, 2010 at 11:26 AM, Dan Mueller <span dir="ltr">&lt;<a href="mailto:dan.muel@gmail.com">dan.muel@gmail.com</a>&gt;</span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">
Hi Ali,<br>
<br>
Try the following to get the image buffer as a pointer:<br>
    InputPixelType* buffer = image_1-&gt;GetBufferPointer();<br>
<br>
You can then treat the buffer as a simple pointer (e.g. cast to<br>
unsigned char *, whatever).<br>
<br>
Determining if the pixel type is scalar or not is a little trickier.<br>
At first glance the method<br>
itk::ImageBase::GetNumberOfComponentsPerPixel() seems helpful, but it<br>
does not work as you might expect (see documentation). I&#39;m not sure if<br>
there is a better way, but I use a specialized traits class to help<br>
(see below). You use the class as follows:<br>
    InputPixelType pixel;<br>
    unsigned int numComponents =<br>
itk::VectorPixelTraits&lt;InputPixelType&gt;::GetNumberOfComponents(pixel);<br>
<br>
HTH<br>
<br>
Cheers, Dan<br>
<br>
/*=========================================================================<br>
<br>
  Program:   Insight Segmentation &amp; Registration Toolkit<br>
  Module:    $RCSfile: itkVectorPixelTraits.h,v $<br>
  Language:  C++<br>
  Date:      $Date$<br>
  Version:   $Revision$<br>
<br>
  Copyright (c) Insight Software Consortium. All rights reserved.<br>
  See ITKCopyright.txt or <a href="http://www.itk.org/HTML/Copyright.htm" target="_blank">http://www.itk.org/HTML/Copyright.htm</a> for details.<br>
<br>
     This software is distributed WITHOUT ANY WARRANTY; without even<br>
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR<br>
     PURPOSE.  See the above copyright notices for more information.<br>
<br>
=========================================================================*/<br>
#ifndef __itkVectorPixelTraits_h<br>
#define __itkVectorPixelTraits_h<br>
<br>
#include &quot;itkMacro.h&quot;<br>
#include &quot;itkArray.h&quot;<br>
#include &quot;itkVector.h&quot;<br>
#include &quot;itkFixedArray.h&quot;<br>
#include &quot;itkRGBPixel.h&quot;<br>
#include &quot;itkRGBAPixel.h&quot;<br>
#include &quot;itkVariableLengthVector.h&quot;<br>
#include &quot;itkNumericTraits.h&quot;<br>
<br>
namespace itk<br>
{<br>
<br>
/** \class VectorPixelTraits<br>
 * \brief Define additional traits for vector pixels (eg. fixed array, RGB).<br>
 *<br>
 * VectorPixelTraits is used to extend the traits associated with vector pixel<br>
 * types such as fixed array, RGBPixel, VariableLengthVector, and so on.<br>
 * These traits also support scalar types (such as unsigned char, short)<br>
 * so that both vector and scalar types can be treated in a unified way.<br>
 *<br>
 * Note this default implementation defines traits for all scalar types<br>
 * (eg. unsigned char, short, double, etc).<br>
 *<br>
 * \ingroup DataRepresentation<br>
 */<br>
template &lt;class T&gt;<br>
class VectorPixelTraits {<br>
public:<br>
  /** Get the number of components for the given type.<br>
    * An input is required for variable length types whose<br>
    * length is defined at run-time rather than compile-time.<br>
    * For other types the input is simply ignored. */<br>
  static unsigned int GetNumberOfComponents( T input ) { return 1; }<br>
<br>
  /* Return the reference to the given indexed element in the vector. */<br>
  static T *GetElement( unsigned int i, T *pixel ) { return pixel; }<br>
<br>
  /* Set the value of the left element with the value of the right. */<br>
  static void SetElement( unsigned int i, T &amp;left, T right ) { left = right; }<br>
<br>
  /* Return the zero value. */<br>
  static T ZeroValue( T input ) { return NumericTraits&lt;T&gt;::ZeroValue(); }<br>
<br>
  /* Convert the given double to the pixel type.<br>
     NOTE: This is not implemented for VariableLengthVectors! */<br>
  static T Convert( double input ) { return static_cast&lt;T&gt;(input); }<br>
};<br>
<br>
/** Define a macro to be used for RGB types. */<br>
#define RGBSTATICTRAITSMACRO( T, E ) \<br>
template&lt;&gt; \<br>
class VectorPixelTraits&lt; T&lt;E&gt; &gt; { \<br>
public: \<br>
  static unsigned int GetNumberOfComponents( T&lt;E&gt; input ) \<br>
    { return 3; } \<br>
  static E *GetElement( unsigned int i, T&lt;E&gt; *pixel ) \<br>
    { return &amp;((*pixel)[i]); } \<br>
  static void SetElement( unsigned int i, T&lt;E&gt; &amp;left, T&lt;E&gt; right ) \<br>
    { left[i] = right[i]; } \<br>
  static T&lt;E&gt; ZeroValue( T&lt;E&gt; input ) \<br>
    { return NumericTraits&lt;T&lt;E&gt;&gt;::ZeroValue(); } \<br>
  static T&lt;E&gt; Convert( double input ) \<br>
    { T&lt;E&gt; value( static_cast&lt;E&gt;(input) ); return value; } \<br>
}; \<br>
<br>
RGBSTATICTRAITSMACRO( RGBPixel, unsigned char );<br>
RGBSTATICTRAITSMACRO( RGBPixel, signed char );<br>
RGBSTATICTRAITSMACRO( RGBPixel, unsigned short );<br>
RGBSTATICTRAITSMACRO( RGBPixel, signed short );<br>
RGBSTATICTRAITSMACRO( RGBPixel, unsigned long );<br>
RGBSTATICTRAITSMACRO( RGBPixel, signed long );<br>
RGBSTATICTRAITSMACRO( RGBPixel, float );<br>
RGBSTATICTRAITSMACRO( RGBPixel, double );<br>
<br>
/** Define a macro to be used for RGBA types. */<br>
#define RGBASTATICTRAITSMACRO( T, E ) \<br>
template&lt;&gt; \<br>
class VectorPixelTraits&lt; T&lt;E&gt; &gt; { \<br>
public: \<br>
  static unsigned int GetNumberOfComponents( T&lt;E&gt; input ) { return 4; } \<br>
  static E *GetElement( unsigned int i, T&lt;E&gt; *pixel ) { return<br>
&amp;((*pixel)[i]); } \<br>
  static void SetElement( unsigned int i, T&lt;E&gt; &amp;left, T&lt;E&gt; right ) {<br>
left[i] = right[i]; } \<br>
  static T&lt;E&gt; ZeroValue( T&lt;E&gt; input ) { T&lt;E&gt; zero =<br>
NumericTraits&lt;T&lt;E&gt;&gt;::ZeroValue(); zero.SetAlpha( 254 ); return zero; }<br>
\<br>
  static T&lt;E&gt; Convert( double input ) { T&lt;E&gt; value(<br>
static_cast&lt;E&gt;(input) ); return value; } \<br>
}; \<br>
<br>
RGBASTATICTRAITSMACRO( RGBAPixel, unsigned char );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, signed char );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, unsigned short );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, signed short );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, unsigned long );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, signed long );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, float );<br>
RGBASTATICTRAITSMACRO( RGBAPixel, double );<br>
<br>
/** Define a macro to be used for all (fixed) array types. */<br>
#define FIXEDARRAYSTATICTRAITSMACRO( T, E, N ) \<br>
template&lt;&gt; \<br>
class VectorPixelTraits&lt; T&lt;E,N&gt; &gt; { \<br>
public: \<br>
  static unsigned int GetNumberOfComponents(T&lt;E,N&gt; input) { return N; } \<br>
  static E *GetElement( unsigned int i, T&lt;E,N&gt; *pixel) { return<br>
&amp;((*pixel)[i]); } \<br>
  static void SetElement( unsigned int i, T&lt;E,N&gt; &amp;left, T&lt;E,N&gt; right)<br>
{ left[i] = right[i]; } \<br>
  static T&lt;E,N&gt; ZeroValue( T&lt;E,N&gt; input ) { T&lt;E,N&gt; zero; zero.Fill(<br>
NumericTraits&lt;E&gt;::ZeroValue() ); return zero; } \<br>
  static T&lt;E,N&gt; Convert( double input ) { T&lt;E,N&gt; value; value.Fill(<br>
static_cast&lt;E&gt;(input) ); return value; } \<br>
}; \<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned char, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed char, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned short, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed short, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned long, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed long, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, float, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, double, 1 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned char, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed char, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned short, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed short, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned long, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed long, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, float, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, double, 2 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned char, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed char, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned short, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed short, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned long, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed long, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, float, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, double, 3 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned char, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed char, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned short, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed short, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, unsigned long, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, signed long, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, float, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( FixedArray, double, 4 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned char, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed char, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned short, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed short, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned long, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed long, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, float, 1 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, double, 1 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned char, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed char, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned short, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed short, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned long, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed long, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, float, 2 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, double, 2 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned char, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed char, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned short, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed short, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned long, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed long, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, float, 3 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, double, 3 );<br>
<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned char, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed char, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned short, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed short, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, unsigned long, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, signed long, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, float, 4 );<br>
FIXEDARRAYSTATICTRAITSMACRO( Vector, double, 4 );<br>
<br>
/** Define a macro to be used for all (variable) array types. */<br>
#define VARIABLEARRAYSTATICTRAITSMACRO( T, E ) \<br>
template&lt;&gt; \<br>
class VectorPixelTraits&lt; T&lt;E&gt; &gt; { \<br>
public: \<br>
  static unsigned int GetNumberOfComponents(T&lt;E&gt; input) { return<br>
input.Size(); } \<br>
  static E *GetElement( unsigned int i, T&lt;E&gt; *pixel) { return<br>
&amp;((*pixel)[i]); } \<br>
  static void SetElement( unsigned int i, T&lt;E&gt; &amp;left, T&lt;E&gt; right) {<br>
left[i] = right[i]; } \<br>
  static T&lt;E&gt; ZeroValue( T&lt;E&gt; input ) { return<br>
NumericTraits&lt;T&lt;E&gt;&gt;::Zero(input); } \<br>
  static T&lt;E&gt; Convert( double input ) { T&lt;E&gt; value; /* NOT IMPLEMENTED<br>
*/ return value; } \<br>
}; \<br>
<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, unsigned char );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, signed char );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, unsigned short );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, signed short );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, unsigned long );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, signed long );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, float );<br>
VARIABLEARRAYSTATICTRAITSMACRO( VariableLengthVector, double );<br>
<br>
} // end namespace itk<br>
<br>
#endif<br>
<div><div></div><div class="h5"><br>
<br>
On 28 December 2010 09:52, Ali Habib &lt;<a href="mailto:ali.mahmoud.habib@gmail.com">ali.mahmoud.habib@gmail.com</a>&gt; wrote:<br>
&gt; Dear All,<br>
&gt; I need the pixel data as unsigned char* , I created my pipeline but I stuck<br>
&gt; on how to get the buffer data , also I need to know does the pixel_value<br>
&gt; will show me if the input is scaler or not<br>
&gt; the code I use is :<br>
&gt; typedef signed short InputPixelType;<br>
&gt; const unsigned int   InputDimension = 2;<br>
&gt; typedef itk::Image&lt; InputPixelType, InputDimension &gt; InputImageType;<br>
&gt; typedef itk::ImageFileReader&lt; InputImageType &gt; ReaderType;<br>
&gt; typedef InputImageType::SizeType         SizeType;<br>
&gt; ReaderType::Pointer reader = ReaderType::New();<br>
&gt; reader-&gt;SetFileName( &quot;4.dcm&quot; );<br>
&gt; typedef itk::GDCMImageIO           ImageIOType;<br>
&gt; ImageIOType::Pointer gdcmImageIO = ImageIOType::New();<br>
&gt; reader-&gt;SetImageIO( gdcmImageIO );<br>
&gt; try<br>
&gt;     {<br>
&gt; reader-&gt;Update();<br>
&gt;     }<br>
&gt; catch (itk::ExceptionObject &amp; e)<br>
&gt;     {<br>
&gt; std::cerr &lt;&lt; &quot;exception in file reader &quot; &lt;&lt; std::endl;<br>
&gt; std::cerr &lt;&lt; e &lt;&lt; std::endl;<br>
&gt; //          return EXIT_FAILURE;<br>
&gt;     }<br>
&gt; InputImageType::Pointer image_1 = reader-&gt;GetOutput() ;<br>
&gt; // the image parameters<br>
&gt; unsigned long lwidth = image_1-&gt;GetLargestPossibleRegion().GetSize()[0] ;<br>
&gt; unsigned long lheight = image_1-&gt;GetLargestPossibleRegion().GetSize()[1] ;<br>
&gt; InputImageType::IndexType index;<br>
&gt; index[0]=1;<br>
&gt; index[1]=1;<br>
&gt; signed short pixel_value;<br>
&gt; pixel_value= image_1-&gt;GetPixel( index );<br>
</div></div></blockquote></div><br></div></div>