ImageView.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.6.11
// ----------------------------------------------------------------------------
// pcl/ImageView.h - Released 2024-05-07T15:27:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_ImageView_h
#define __PCL_ImageView_h
 
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#include <pcl/Defs.h>
 
#include <pcl/AutoPointer.h>
#include <pcl/ImageVariant.h>
#include <pcl/ImageWindow.h>
#include <pcl/ScrollBox.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS ImageView : public ScrollBox
{
public:
 
   using gui_mode = ImageMode::value_type;
 
   using display_channel = DisplayChannel::value_type;
 
   using background_brush = BackgroundBrush::value_type;
 
   using transparency_mode = TransparencyMode::value_type;
 
   ImageView( Control& parent = Control::Null(),
              int width = 0, int height = 0, int numberOfChannels = 1,
              int bitsPerSample = 32, bool floatSample = true, bool color = false );
 
   ~ImageView() override
   {
   }
 
   ImageVariant Image() const;
 
   bool IsColorImage() const;
 
   void GetImageGeometry( int& width, int& height, int& numberOfChannels ) const;
 
   int ImageWidth() const
   {
      int w, dum; GetImageGeometry( w, dum, dum ); return w;
   }
 
   int ImageHeight() const
   {
      int dum, h; GetImageGeometry( dum, h, dum ); return h;
   }
 
   Rect ImageBounds() const
   {
      int w, h, dum; GetImageGeometry( w, h, dum ); return Rect( w, h );
   }
 
   void GetSampleFormat( int& bitsPerSample, bool& floatSample ) const;
 
   void SetSampleFormat( int bitsPerSample, bool floatSample );
 
   void GetRGBWS( RGBColorSystem& rgbws ) const;
 
   void SetRGBWS( const RGBColorSystem& rgbws );
 
   bool IsColorManagementEnabled() const;
 
   void EnableColorManagement( bool = true );
 
   void DisableColorManagement( bool disable = true )
   {
      EnableColorManagement( !disable );
   }
 
   bool IsProofingEnabled() const;
 
   void EnableProofing( bool = true );
 
   void DisableProofing( bool disable = true )
   {
      EnableProofing( !disable );
   }
 
   bool IsGamutCheckEnabled() const;
 
   void EnableGamutCheck( bool = true );
 
   void DisableGamutCheck( bool disable = true )
   {
      EnableGamutCheck( !disable );
   }
 
   void SetColorManagementFeatures( bool cmEnabled, bool proofing, bool gamutCheck );
 
   bool GetICCProfile( ICCProfile& icc ) const;
 
   void SetICCProfile( const ICCProfile& icc );
 
   void SetICCProfile( const String& filePath );
 
   void DeleteICCProfile();
 
   gui_mode CurrentMode() const;
 
   void SelectMode( gui_mode mode );
 
   display_channel CurrentChannel() const;
 
   bool IsAlphaChannelDisplayed() const
   {
      return CurrentChannel() >= DisplayChannel::Alpha;
   }
 
   int CurrentAlphaChannel() const
   {
      return CurrentChannel() - DisplayChannel::Alpha;
   }
 
   void SelectChannel( display_channel channel );
 
   transparency_mode TransparencyMode() const;
 
   RGBA TransparencyColor() const;
 
   bool IsTransparencyVisible() const
   {
      return TransparencyMode() != pcl::TransparencyMode::Hide;
   }
 
   void SetTransparencyMode( transparency_mode mode, RGBA color = 0 );
 
   void HideTransparency()
   {
      SetTransparencyMode( pcl::TransparencyMode::Hide );
   }
 
   void SetViewport( double cx, double cy, int zoom = 0 );
 
   void SetViewport( const DPoint& center, int zoom = 0 )
   {
      SetViewport( center.x, center.y, zoom );
   }
 
   int ZoomFactor() const;
 
   void SetZoomFactor( int z );
 
   void ZoomIn()
   {
      int z = ZoomFactor() + 1;
      SetZoomFactor( (z > 0) ? z : +1 );
   }
 
   void ZoomOut()
   {
      int z = ZoomFactor() - 1;
      SetZoomFactor( (z > 0 || z < -1) ? z : -2 );
   }
 
   void GetViewportSize( int& width, int& height ) const;
 
   int ViewportWidth() const
   {
      int w, dum;
      GetViewportSize( w, dum );
      return w;
   }
 
   int ViewportHeight() const
   {
      int dum, h;
      GetViewportSize( dum, h );
      return h;
   }
 
   Point ViewportPosition() const;
 
   void SetViewportPosition( int x, int y );
 
   void SetViewportPosition( const Point& p )
   {
      SetViewportPosition( p.x, p.y );
   }
 
   Rect VisibleViewportRect() const;
 
   int VisibleViewportWidth() const
   {
      return VisibleViewportRect().Width();
   }
 
   int VisibleViewportHeight() const
   {
      return VisibleViewportRect().Height();
   }
 
   void ViewportToImage( int& x, int& y ) const;
 
   void ViewportToImage( double& x, double& y ) const;
 
   template <typename T>
   DPoint ViewportToImage( const GenericPoint<T>& p ) const
   {
      DPoint p1 = p;
      ViewportToImage( p1.x, p1.y );
      return p1;
   }
 
   template <typename T>
   DRect ViewportToImage( const GenericRectangle<T>& r ) const
   {
      DRect r1 = r;
      ViewportToImage( r1.x0, r1.y0 );
      ViewportToImage( r1.x1, r1.y1 );
      return r1;
   }
 
   void ViewportToImage( Point* p, size_type n ) const;
 
   void ViewportToImage( DPoint* p, size_type n ) const;
 
   template <typename T>
   void ViewportToImage( Array<GenericPoint<T> >& a ) const
   {
      ViewportToImage( a.Begin(), a.Length() );
   }
 
   void ViewportScalarToImage( int* d, size_type n ) const;
 
   void ViewportScalarToImage( double* d, size_type n ) const;
 
   double ViewportScalarToImage( double d ) const;
 
   template <typename T>
   double ViewportScalarToImage( T d ) const
   {
      return ViewportScalarToImage( double( d ) );
   }
 
   void ImageToViewport( int& x, int& y ) const;
 
   void ImageToViewport( double& x, double& y ) const;
 
   template <typename T>
   GenericPoint<T> ImageToViewport( const GenericPoint<T>& p ) const
   {
      GenericPoint<T> p1 = p;
      ImageToViewport( p1.x, p1.y );
      return p1;
   }
 
   template <typename T>
   GenericRectangle<T> ImageToViewport( const GenericRectangle<T>& r ) const
   {
      GenericRectangle<T> r1 = r;
      ImageToViewport( r1.x0, r1.y0 );
      ImageToViewport( r1.x1, r1.y1 );
      return r1;
   }
 
   void ImageToViewport( Point* p, size_type n ) const;
 
   void ImageToViewport( DPoint* p, size_type n ) const;
 
   template <typename T>
   void ImageToViewport( Array<GenericPoint<T> >& a ) const
   {
      ImageToViewport( a.Begin(), a.Length() );
   }
 
   void ImageScalarToViewport( int* d, size_type n ) const;
 
   void ImageScalarToViewport( double* d, size_type n ) const;
 
   int ImageScalarToViewport( int ) const;
 
   double ImageScalarToViewport( double ) const;
 
   void ViewportToGlobal( int& x, int& y ) const;
 
   Point ViewportToGlobal( const Point& p ) const
   {
      Point p1 = p;
      ViewportToGlobal( p1.x, p1.y );
      return p1;
   }
 
   Rect ViewportToGlobal( const Rect& r ) const
   {
      Rect r1 = r;
      ViewportToGlobal( r1.x0, r1.y0 );
      ViewportToGlobal( r1.x1, r1.y1 );
      return r1;
   }
 
   void GlobalToViewport( int& x, int& y ) const;
 
   Point GlobalToViewport( const Point& p ) const
   {
      Point p1 = p;
      GlobalToViewport( p1.x, p1.y );
      return p1;
   }
 
   Rect GlobalToViewport( const Rect& r ) const
   {
      Rect r1 = r;
      GlobalToViewport( r1.x0, r1.y0 );
      GlobalToViewport( r1.x1, r1.y1 );
      return r1;
   }
 
   void Reset()
   {
      SetZoomFactor( ZoomFactor() );
   }
 
   void Regenerate();
 
   void RegenerateViewportRect( const Rect& r )
   {
      RegenerateViewportRect( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void RegenerateViewportRect( int x0, int y0, int x1, int y1 );
 
   void RegenerateImageRect( const pcl::DRect& r )
   {
      RegenerateImageRect( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void RegenerateImageRect( double x0, double y0, double x1, double y1 );
 
   void UpdateViewport();
 
   void UpdateViewportRect( const Rect& r )
   {
      UpdateViewportRect( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void UpdateViewportRect( int x0, int y0, int x1, int y1 );
 
   void UpdateImageRect( const pcl::DRect& r )
   {
      UpdateImageRect( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void UpdateImageRect( double x0, double y0, double x1, double y1 );
 
   bool HasPendingUpdates() const;
 
   void CommitPendingUpdates();
 
   Rect ViewportUpdateRect() const;
 
   Bitmap ViewportBitmap( const Rect& r, uint32 flags = 0 ) const
   {
      return ViewportBitmap( r.x0, r.y0, r.x1, r.y1, flags );
   }
 
   Bitmap ViewportBitmap( int x0, int y0, int x1, int y1, uint32 flags = 0 ) const;
 
   void BeginSelection( const Point& p, uint32 flags = 0 )
   {
      BeginSelection( p.x, p.y, flags );
   }
 
   void BeginSelection( int x, int y, uint32 flags = 0 );
 
   void ModifySelection( const Point& p, uint32 flags = 0 )
   {
      ModifySelection( p.x, p.y, flags );
   }
 
   void ModifySelection( int x, int y, uint32 flags = 0 );
 
   void UpdateSelection();
 
   void CancelSelection();
 
   void EndSelection();
 
   Rect SelectionRect( uint32* flags = 0 ) const;
 
   bool IsSelection() const;
 
   // -------------------------------------------------------------------------
   // Event handlers
   //
   // void OnScrollViewport( ImageView& sender, int dx, int dy );
 
   using scroll_event_handler = void (Control::*)( ImageView& sender, int dx, int dy );
 
   void OnScrollViewport( scroll_event_handler handler, Control& receiver );
 
private:
 
   struct EventHandlers
   {
      scroll_event_handler onScrollViewport = nullptr;
 
      EventHandlers() = default;
      EventHandlers( const EventHandlers& ) = default;
      EventHandlers& operator =( const EventHandlers& ) = default;
   };
 
   AutoPointer<EventHandlers> m_handlers;
 
protected:
 
   ImageView( void* );
 
   ImageView( void*, void* );
 
   friend class ImageViewEventDispatcher;
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#endif   // __PCL_ImageView_h
 
// ----------------------------------------------------------------------------
// EOF pcl/ImageView.h - Released 2024-05-07T15:27:32Z