C++ GenericImage::AllocateData方法代码示例

static void ReadJP2KImage( GenericImage<P>& img, jas_stream_t* jp2Stream, jas_image_t* jp2Image )
{
   int width = jas_image_cmptwidth( jp2Image, 0 );
   int height = jas_image_cmptheight( jp2Image, 0 );
   int numberOfChannels = jas_image_numcmpts( jp2Image );

   jas_matrix_t* pixels = nullptr;

   try
   {
      pixels = jas_matrix_create( 1, width );
      if ( pixels == nullptr )
         throw Error( "Memory allocation error reading JPEG2000 image" );

      // Allocate pixel data
      img.AllocateData( width, height, numberOfChannels,
                        (jas_clrspc_fam( jas_image_clrspc( jp2Image ) ) == JAS_CLRSPC_FAM_GRAY) ?
                              ColorSpace::Gray : ColorSpace::RGB );

      for ( int c = 0; c < numberOfChannels; ++c )
      {
         int n = jas_image_cmptprec( jp2Image, c );
         bool s = jas_image_cmptsgnd( jp2Image, c ) != 0;

         for ( int y = 0; y < height; ++y )
         {
            jas_image_readcmpt( jp2Image, c, 0, y, width, 1, pixels );

            typename P::sample* f = img.ScanLine( y, c );

            if ( n == 8 )
            {
               if ( s )
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( int8( jas_matrix_get( pixels, 0, x ) ) );
               else
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( uint8( jas_matrix_get( pixels, 0, x ) ) );
            }
            else
            {
               if ( s )
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( int16( jas_matrix_get( pixels, 0, x ) ) );
               else
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( uint16( jas_matrix_get( pixels, 0, x ) ) );
            }
         }
      }

      jas_matrix_destroy( pixels ), pixels = nullptr;
   }
   catch ( ... )
   {
      if ( pixels != nullptr )
         jas_matrix_destroy( pixels );
      throw;
   }
}

static void LoadAndTransformImage( GenericImage<P>& transform, const GenericImage<P1>& image, bool parallel, int maxProcessors )
{
   Rect r = image.SelectedRectangle();
   if ( !r.IsRect() )
      return;

   int w = FFTC::OptimizedLength( r.Width() );
   int h = FFTC::OptimizedLength( r.Height() );

   int dw2 = (w - r.Width()) >> 1;
   int dh2 = (h - r.Height()) >> 1;

   transform.AllocateData( w, h, image.NumberOfSelectedChannels(),
                           (image.NumberOfSelectedChannels() < 3 || image.FirstSelectedChannel() != 0) ?
                                 ColorSpace::Gray : image.ColorSpace() );
   transform.Zero().Move( image, Point( dw2, dh2 ) );

   ApplyInPlaceFourierTransform( transform, FFTDirection::Forward, parallel, maxProcessors );
}

static void ApplyInverseRealFourierTransform_2( GenericImage<P>& image, const GenericImage<P1>& dft, bool parallel, int maxProcessors )
{
   if ( dft.IsEmpty() )
   {
      image.FreeData();
      return;
   }

   int w = dft.Width();
   int h = dft.Height();

   image.AllocateData( 2*(w - 1), h, dft.NumberOfChannels(), dft.ColorSpace() );

   bool statusInitialized = false;
   if ( image.Status().IsInitializationEnabled() )
   {
      image.Status().Initialize( "Inverse FFT", image.NumberOfChannels()*size_type( w + h ) );
      image.Status().DisableInitialization();
      statusInitialized = true;
   }

   try
   {
      FFTR F( h, w, image.Status() );
      F.EnableParallelProcessing( parallel, maxProcessors );
      for ( int c = 0; c < image.NumberOfChannels(); ++c )
         F( image[c], dft[c] );
      if ( statusInitialized )
         image.Status().EnableInitialization();
   }
   catch ( ... )
   {
      if ( statusInitialized )
         image.Status().EnableInitialization();
      throw;
   }
}

static void ReadJPEGImage( GenericImage<P>& img, JPEGReader& reader, JPEGFileData* fileData )
{
   if ( !reader.IsOpen() )
      throw JPEG::InvalidReadOperation( String() );

   JSAMPLE* buffer = nullptr;        // one-row sample array for scanline reading
   typename P::sample** v = nullptr; // pointers to destination scan lines

   try
   {
      // Set parameters for decompression.
      // Most parameters have already been established by Open().
      // We just ensure that we'll get either a grayscale or a RGB color image.
      if ( jpeg_decompressor->out_color_space != JCS_GRAYSCALE )
         jpeg_decompressor->out_color_space = JCS_RGB;

      // Start decompressor.
      ::jpeg_start_decompress( jpeg_decompressor );

      // Allocate pixel data.
      img.AllocateData( jpeg_decompressor->output_width,
                        jpeg_decompressor->output_height,
                        jpeg_decompressor->output_components,
                  (jpeg_decompressor->out_color_space == JCS_GRAYSCALE) ?
                        ColorSpace::Gray : ColorSpace::RGB );

      // Initialize status callback.
      if ( img.Status().IsInitializationEnabled() )
         img.Status().Initialize( String().Format(
                  "Decompressing JPEG: %d channel(s), %dx%d pixels",
                  img.NumberOfChannels(), img.Width(), img.Height() ), img.NumberOfSamples() );

      //
      // Read pixels row by row.
      //

      // JSAMPLEs per row in output buffer.
      int row_stride = img.Width() * img.NumberOfChannels();

      // Make a one-row-high sample array.
      buffer = new JSAMPLE[ row_stride ];

      // JPEG organization is chunky; PCL images are planar.
      v = new typename P::sample*[ img.NumberOfChannels() ];

      while ( jpeg_decompressor->output_scanline < jpeg_decompressor->output_height )
      {
         ::jpeg_read_scanlines( jpeg_decompressor, &buffer, 1 );

         const JSAMPLE* b = buffer;

         for ( int c = 0; c < img.NumberOfChannels(); ++c )
            v[c] = img.ScanLine( jpeg_decompressor->output_scanline-1, c );

         for ( int i = 0; i < img.Width(); ++i )
            for ( int c = 0; c < img.NumberOfChannels(); ++c, ++b )
               *v[c]++ = P::IsFloatSample() ? typename P::sample( *b ) : P::ToSample( *b );

         img.Status() += img.Width()*img.NumberOfChannels();
      }

      // Clean up temporary structures.
      delete [] v, v = nullptr;
      delete [] buffer, buffer = nullptr;

      // Finish decompression.
      ::jpeg_finish_decompress( jpeg_decompressor );

      // ### TODO --> At this point we might check whether any corrupt-data
      // warnings occurred (test whether jerr.pub.num_warnings is nonzero).
   }
   catch ( ... )
   {
      reader.Close();

      if ( buffer != nullptr )
         delete [] buffer;
      if ( v != nullptr )
         delete [] v;

      img.FreeData();

      throw;
   }
}