www.pudn.com > DalsaNetlink.rar > ColorAdjustmentDialog.cpp

// ColorAdjustmentDialog.cpp : implementation file 
// 
 
#include "stdafx.h" 
#include "CyApp.h" 
#include "ColorAdjustmentDialog.h" 
#include "CyAcquisitionPage.h" 
#include  
#include  
#include  
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// ColorAdjustmentDialog dialog 
 
 
ColorAdjustmentDialog::ColorAdjustmentDialog( CWnd*              pParent, 
                                              CyAcquisitionPage& aOwner, 
                                              CyRGBFilter&       aFilter, 
                                              CyImageBuffer&     aBuffer, 
                                              unsigned long      aFlags ) 
	: CDialog(ColorAdjustmentDialog::IDD, pParent) 
    , mFilter( aFilter ) 
    , mOwner( aOwner ) 
    , mBuffer( aBuffer ) 
    , mFlags( aFlags ) 
{ 
	//{{AFX_DATA_INIT(ColorAdjustmentDialog) 
	mBlueGain = 0.0; 
	mBlueOffset = 0; 
	mGreenGain = 0.0; 
	mGreenOffset = 0; 
	mRedGain = 0.0; 
	mRedOffset = 0; 
	//}}AFX_DATA_INIT 
 
    // Get the offset from index 0's value 
    mRedOffset = aFilter.GetRedValue16( 0 ); 
    mGreenOffset = aFilter.GetGreenValue16( 0 ); 
    mBlueOffset = aFilter.GetBlueValue16( 0 ); 
 
    // get the gains from the filter 
    mRedGain = static_cast( aFilter.GetRedValue16( 255 ) ); 
    mRedGain = ( mRedGain - static_cast( mRedOffset ) ) / 255.0; 
    mGreenGain = static_cast( aFilter.GetGreenValue16( 255 ) ); 
    mGreenGain = ( mGreenGain - static_cast( mGreenOffset ) ) / 255.0; 
    mBlueGain = static_cast( aFilter.GetBlueValue16( 255 ) ); 
    mBlueGain = ( mBlueGain - static_cast( mBlueOffset ) ) / 255.0; 
 
    // set the WG gains to 1.0f 
    mWBRedGain = 1.0; 
    mWBGreenGain = 1.0; 
    mWBBlueGain = 1.0; 
} 
 
 
void ColorAdjustmentDialog::DoDataExchange(CDataExchange* pDX) 
{ 
	CDialog::DoDataExchange(pDX); 
	//{{AFX_DATA_MAP(ColorAdjustmentDialog) 
	DDX_Control(pDX, IDC_COLOR_ADJUST_WB_RESULT, mWBResultControl); 
	DDX_Text(pDX, IDC_BLUE_GAIN, mBlueGain); 
	DDV_MinMaxDouble(pDX, mBlueGain, 1.e-004, 1000000.); 
	DDX_Text(pDX, IDC_BLUE_OFFSET, mBlueOffset); 
	DDV_MinMaxUInt(pDX, mBlueOffset, 0, 65535); 
	DDX_Text(pDX, IDC_GREEN_GAIN, mGreenGain); 
	DDV_MinMaxDouble(pDX, mGreenGain, 1.e-004, 1000000.); 
	DDX_Text(pDX, IDC_GREEN_OFFSET, mGreenOffset); 
	DDV_MinMaxUInt(pDX, mGreenOffset, 0, 65535); 
	DDX_Text(pDX, IDC_RED_GAIN, mRedGain); 
	DDV_MinMaxDouble(pDX, mRedGain, 1.e-004, 1000000.); 
	DDX_Text(pDX, IDC_RED_OFFSET, mRedOffset); 
	DDV_MinMaxUInt(pDX, mRedOffset, 0, 65535); 
	//}}AFX_DATA_MAP 
} 
 
 
BEGIN_MESSAGE_MAP(ColorAdjustmentDialog, CDialog) 
	//{{AFX_MSG_MAP(ColorAdjustmentDialog) 
	ON_WM_CLOSE() 
	ON_BN_CLICKED(IDC_COLOR_ADJUST_WB_ANALYZE, OnColorAdjustWbAnalyze) 
	ON_BN_CLICKED(IDC_COLOR_ADJUST_WB_APPLY, OnColorAdjustWbApply) 
	ON_BN_CLICKED(IDC_APPLY_GAINS_OFFSETS, OnApplyGainsOffsets) 
	ON_BN_CLICKED(IDC_RESET_GAINS_OFFSETS, OnResetGainsOffsets) 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// ColorAdjustmentDialog message handlers 
 
void ColorAdjustmentDialog::OnOK()  
{ 
    mOwner.PostMessage( WM_COMMAND, IDC_COLOR_ADJUST_CLOSED ); 
	 
	CDialog::OnOK(); 
} 
 
void ColorAdjustmentDialog::OnCancel()  
{ 
    mOwner.PostMessage( WM_COMMAND, IDC_COLOR_ADJUST_CLOSED ); 
	 
	CDialog::OnCancel(); 
} 
 
void ColorAdjustmentDialog::OnClose()  
{ 
	mOwner.PostMessage( WM_COMMAND, IDC_COLOR_ADJUST_CLOSED ); 
	 
	CDialog::OnClose(); 
} 
 
void ColorAdjustmentDialog::OnColorAdjustWbAnalyze()  
{ 
    unsigned long lQueueSize = mBuffer.GetQueueSize(); 
    if ( lQueueSize < 2 ) 
        mBuffer.SetQueueSize( 2 ); 
 
    // Grab a frame 
    unsigned char * lPtr; 
    unsigned long lSize; 
    CyBuffer::ReadLockID lID; 
    if ( mBuffer.LockForRead( (void**) &lPtr, &lSize, &lID, CyBuffer::FLAG_NO_WAIT | CyBuffer::FLAG_ERROR_IF_EMPTY ) != CY_RESULT_OK ) 
    { 
        mBuffer.SetQueueSize( lQueueSize ); 
        MessageBox( "Could not obtain frame from source.  Acquisition must be in continuous mode." ); 
        return; 
    } 
 
 
    // Convert to RGB 24, WITHOUT filtering 
    CyRGB24 lOutputPixel; 
    if ( !lOutputPixel.HasConverterFrom( mBuffer.GetFormat() ) ) 
    { 
        mBuffer.SignalReadEnd( lID ); 
        mBuffer.SetQueueSize( lQueueSize ); 
        MessageBox( "There is no conversion available from the actual pixel type" ); 
        return; 
    } 
    const CyPixelConverter& lConverter = lOutputPixel.GetConverterFrom( mBuffer.GetFormat() ); 
    unsigned char * lBuffer = new unsigned char[ lOutputPixel.GetBufferSizeFor( mBuffer.GetSizeX(), mBuffer.GetSizeY() ) ]; 
    if ( lConverter.Convert( lPtr, 
                             mBuffer.GetSizeX(), mBuffer.GetSizeY(), 
                             lBuffer, 
                             mBuffer.GetSizeX(), mBuffer.GetSizeY(), 
                             mBuffer.GetSizeX(), mBuffer.GetSizeY(), 
                             mFlags ) != CY_RESULT_OK ) 
    { 
        mBuffer.SignalReadEnd( lID ); 
        mBuffer.SetQueueSize( lQueueSize ); 
        delete [] lBuffer; 
        MessageBox( "Could not convert acquired data to RGB 24-bit" ); 
        return; 
    } 
    mBuffer.SignalReadEnd( lID ); 
    mBuffer.SetQueueSize( lQueueSize ); 
 
    // Compute the mean value of each channel 
    double lRedSum = 0;  
    double lGreenSum = 0;  
    double lBlueSum = 0;  
    double lCount = 0; 
    lPtr = lBuffer; 
    for ( unsigned long j = 0; j < mBuffer.GetSizeY(); ++j ) 
    { 
        for ( unsigned long i = 0; i < mBuffer.GetSizeX(); i += 4 ) 
        { 
            lRedSum   += *lPtr++; 
            lGreenSum += *lPtr++; 
            lBlueSum  += *lPtr++; 
 
            lRedSum   += *lPtr++; 
            lGreenSum += *lPtr++; 
            lBlueSum  += *lPtr++; 
 
            lRedSum   += *lPtr++; 
            lGreenSum += *lPtr++; 
            lBlueSum  += *lPtr++; 
 
            lRedSum   += *lPtr++; 
            lGreenSum += *lPtr++; 
            lBlueSum  += *lPtr++; 
 
            lCount += 4; 
        } 
    } 
    delete [] lBuffer; 
 
    lRedSum /= lCount; 
    lGreenSum /= lCount; 
    lBlueSum /= lCount; 
 
    mWBRedGain = lRedSum; 
    mWBGreenGain = lGreenSum; 
    mWBBlueGain = lBlueSum; 
    double lLargest = max( mWBRedGain, max( mWBGreenGain, mWBBlueGain ) ); 
    mWBRedGain = lLargest / mWBRedGain; 
    mWBGreenGain = lLargest / mWBGreenGain; 
    mWBBlueGain = lLargest / mWBBlueGain; 
 
    // Display the results 
    CString lTemp; 
    lTemp.Format( "Mean RGB value = (%u, %u, %u),\nSuggested RGB gain = (%3.3f, %3.3f, %3.3f)", 
                  static_cast( lRedSum ), 
                  static_cast( lGreenSum ), 
                  static_cast( lBlueSum ), 
                  mWBRedGain, 
                  mWBGreenGain, 
                  mWBBlueGain ); 
    mWBResultControl.SetWindowText( lTemp ); 
} 
 
void ColorAdjustmentDialog::OnColorAdjustWbApply()  
{ 
    mRedGain   = mWBRedGain; 
    mGreenGain = mWBGreenGain; 
    mBlueGain  = mWBBlueGain; 
 
    if ( !UpdateData( FALSE ) ) 
        return; 
 
    OnApplyGainsOffsets(); 
} 
 
void ColorAdjustmentDialog::OnApplyGainsOffsets()  
{ 
	if ( !UpdateData() ) 
        return; 
 
    mFilter.SetMultipliers( mRedGain, mGreenGain, mBlueGain, mRedOffset, mGreenOffset, mBlueOffset ); 
} 
 
void ColorAdjustmentDialog::OnResetGainsOffsets()  
{ 
    mRedGain   = 1.0; 
    mGreenGain = 1.0; 
    mBlueGain  = 1.0; 
    mRedOffset = 0; 
    mGreenOffset = 0; 
    mBlueOffset = 0; 
 
    if ( !UpdateData( FALSE ) ) 
        return; 
 
    mFilter.SetMultipliers( mRedGain, mGreenGain, mBlueGain, mRedOffset, mGreenOffset, mBlueOffset ); 
}