Error C2065: col_gray: необъявленный идентификатор

#include "stdafx.h"
#include "lab01.h"
 
lab07::lab07() : m_pBits( 0 )
{ 
    m_Imps.push_back( new s_imp_gray_scale );
    m_Imps.push_back( new s_imp_sharp );
    m_Imps.push_back( new s_imp_blur );
}
 
bool lab07::Input( const char* image_file )
{
    if( !m_Src.load( image_file ) )
        return false;
 
    return true;
}
 
void lab07::Init()
{
    for( t_imps::const_iterator i = m_Imps.begin(), e = m_Imps.end(); i != e; ++i )
        (*i)->Upload( &m_Src );
}
 
void lab07::Process()
{
    int cnt = 0, num = 0;
    char buf[32];
    for( t_imps::const_iterator i = m_Imps.begin(), e = m_Imps.end(); i != e; ++i, ++num )
    {
        if( (*i)->IsEnd() )
        {
            if( (*i)->IsReady() )
            {   sprintf_s( buf, sizeof( buf ), "result_%02u.tga", num + 1 );
                (*i)->Result().save( buf );
                (*i)->SaveOk();
            }// if( (*i)->IsReady() )
            continue;
        }// if( (*i)->IsEnd() )
 
        (*i)->Process();
        ++cnt;
    }// for( t_imps::const_iterator i = m_Imps.begin(), e = m_Imps.end(); i != e; ++i, ++num )
 
    if( !cnt )
    {
        if( main::m_iAuto <= 1 )
            main::m_iAuto = 2;
 
    }// if( !cnt )
 
}
 
 
void lab07::PrintResults( HDC wdc, HWND wnd ) const
{
    if( !m_Src.width() || m_Imps.empty() )
        return;
 
    RECT rc = { 0 };
    GetClientRect( wnd, &rc );
 
    static HDC dc = CreateCompatibleDC( 0 );
    static HDC mem_dc = CreateCompatibleDC( 0 );
    static HBITMAP bmp = CreateCompatibleBitmap( GetDC( 0 ), rc.right, rc.bottom );
 
    SelectObject( dc, bmp );
 
    HDC out_dc = wdc;
    wdc = dc;
 
    const COLORREF col_dgray = RGB( 80, 80, 80 );
    const COLORREF col_orange = RGB( 224, 112, 0 );
 
    HPEN pen_orange = CreatePen( PS_SOLID, 3, col_orange );
    HPEN pen_dgray = CreatePen( PS_SOLID, 1, col_dgray );
 
    HBRUSH brush_white = CreateSolidBrush( col_white );
 
 
    SelectObject( wdc, brush_white );
    SelectObject( wdc, pen_dgray );
    Rectangle( wdc, rc.left, rc.top, rc.right, rc.bottom );
 
    int cnt = int( m_Imps.size() );
 
    wchar_t buf[256];
    int szw = rc.right - rc.left, bx = szw / 24, sw = szw - bx * 4, firstx = bx * 3;
    int szh = rc.bottom - rc.top, by = szh / 12, sh = szh - by * 2;
    int stepy = sh / cnt, y = by + stepy;
    SIZE siz = { 0 };
 
    static HFONT fnt_dig = CreateFont( 12, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, L"Arial" );
    static HFONT fnt = CreateFont( 15, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, L"Arial" );
 
    static int scr_width = sw, scr_height = stepy - 8;
    static BITMAPINFO bmi =
     { { sizeof( BITMAPINFOHEADER ), scr_width, scr_height, 1, 32, 0, 0, 0, 0, 0, 0 } };
    static HBITMAP mem = CreateDIBSection( mem_dc, &bmi, DIB_RGB_COLORS, &m_pBits, 0, 0 );
 
    SelectObject( mem_dc, mem );
    SetBkMode( wdc, OPAQUE );
 
    {
        SetTextColor( wdc, col_black );
        SetBkColor( wdc, col_white );
        SelectObject( wdc, fnt );
        int sl = wsprintf( buf, (   main::m_iAuto == 1 ?
             L"Tab - отключить автоматический режим" :
            main::m_iAuto == 0 ? 
            L"Tab - включить автоматический режим   Enter - один шаг сортировки" :
            L"Обработка завершена. Нажмите любую клавишу для повторной обработки" )       );
        GetTextExtentPoint32( wdc, buf, sl, &siz ); 
        TextOut( wdc, ( szw - siz.cx ) / 2, 2, buf, sl );
    }
 
    SelectObject( wdc, pen_orange );
 
    for( t_imps::const_iterator i = m_Imps.begin(), e = m_Imps.end(); i != e; ++i, y += stepy )
    {
        s_imp* imp = (*i);
 
        SetBkColor( wdc, col_white );
        SelectObject( wdc, fnt );
 
        bool end = imp->IsEnd();
        {   SetTextColor( wdc, col_black );
            int sl = wsprintf( buf, L"%lS", imp->Name() );
            GetTextExtentPoint32( wdc, buf, sl, &siz ); 
            TextOut( wdc, 6, y - siz.cy * 3, buf, sl );
        }
        SetTextColor( wdc, end ? col_dgray : col_gray );
        {   int sl = wsprintf( buf, L"строка:%-4u (%-4u)", imp->Line(), m_Src.height() );
            GetTextExtentPoint32( wdc, buf, sl, &siz ); 
            TextOut( wdc, 6, y - siz.cy * 2, buf, sl );
        }
        {   int ops = imp->Ops() / 1000;
            int sl = wsprintf( buf, L"тыс. опер:%-4u", ops );
            GetTextExtentPoint32( wdc, buf, sl, &siz ); 
            TextOut( wdc, 6, y - siz.cy, buf, sl );
        }
 
        if( end )
        {
 
            int sl = wsprintf( buf, L"ЗАВЕРШЕНО" );
            TextOut( wdc, 6, y, buf, sl );
 
        }// if( end )
 
        SelectObject( wdc, fnt_dig );
 
        int width = m_Src.width(), height = m_Src.height();
 
        int max_scr_width = scr_width / 2;
        max_scr_width = min( width, max_scr_width );
        int line = imp->Line(), szy = min( height, scr_height );
 
        const h_image& res = imp->Result();
 
        int offsx = max( 0, width - max_scr_width ) / 2;
 
        t_color* p = static_cast<t_color*>( m_pBits );
 
        int roll_y = 0;
        if( end || line == 0 )
        {
            int offsy = max( 0, height - szy ) / 2;
            for( int iy = 0; iy < szy; ++iy )
            {
                for( int ix = 0; ix < max_scr_width; ++ix )
                {
                    t_color src = m_Src.pixel( ix + offsx, iy + offsy );
                    t_color dst = res.pixel( ix + offsx, iy + offsy );
 
                    p[ix + iy * scr_width] = win_color( src );
                    p[( ix + scr_width / 2 ) + iy * scr_width] = win_color( dst );
                    
                }// for( int ix = 0; ix < max_scr_width; ++ix )
 
            }// for( int iy = 0; iy < szy; ++iy )
 
        }// if( end || line == 0 )
        else
        {
            int bias_y = szy * 2 / 3;
            if( line > bias_y )
                roll_y = line - bias_y;
 
            if( szy + roll_y >= height )
                roll_y -= ( szy + roll_y ) - height;
 
 
            for( int iy = 0; iy < szy; ++iy )
            {
                int yy = iy + roll_y;
                if( yy < 0 )
                    continue;
 
                for( int ix = 0; ix < max_scr_width; ++ix )
                {
                    t_color src = m_Src.pixel( ix + offsx, yy );
                    t_color dst = res.pixel( ix + offsx, yy );
 
                    p[ix + iy * scr_width] = win_color( src );
                    p[ix + scr_width / 2 + iy * scr_width] = win_color( dst );
                    
                }// for( int ix = 0; ix < max_scr_width; ++ix )
 
            }// for( int iy = 0; iy < szy; ++iy )
 
        }// else if( end || line == 0 )
 
        int view_y = scr_height - szy;
        BitBlt( wdc, firstx, y - szy, max_scr_width, szy, mem_dc, 0, view_y, SRCCOPY );
        BitBlt( wdc, firstx + max_scr_width + 8, y - szy, max_scr_width, szy,
             mem_dc, scr_width / 2, view_y, SRCCOPY );
 
        if( !end && line )
        {
            int line_y = y - line + roll_y;
            MoveToEx( wdc, firstx, line_y, 0 );
            LineTo( wdc, firstx + max_scr_width * 2 + 8, line_y );
        }// if( !end && line )
 
    }// for( t_imps::const_iterator i = m_Imps.begin(), e = m_Imps.end(); i != e; ++i, y += stepy )
 
    DeleteObject( pen_orange );
    DeleteObject( pen_dgray );
 
    DeleteObject( brush_white );
 
    BitBlt( out_dc, 0, 0, rc.right, rc.bottom, wdc, 0, 0, SRCCOPY );
}
 
 
//считать изображение
bool lab07::h_tga_image::load( const char* img_name )
{
    data.clear();
    wid = hei = 0;
    s_tga_header header;
 
    bool res = false;
    FILE* f = fopen( img_name, "rb" );
    if( !f )
        goto lExit;
 
    fread( &header, 1, sizeof( header ), f );
 
    int it = header.image_type & TGA_FMT_MASK;
    if( it != TGA_TRUECOLOR && it != TGA_BW ) goto lExit;
 
    int components = header.bpp / 8, line_size = header.width * components;
 
    if( components != 1 && components != 3 && components != 4 ) goto lExit;
    if( header.is_rle() ) goto lExit;
 
    wid = header.width;
    hei = header.height;
    int img_size = wid * hei;
    data.resize( img_size );
 
    fseek( f, header.id_len, SEEK_CUR );
 
    switch( components )
    {
    case 1:
    case 3:
        {
            int pit = wid * components;
            vector<t_byte> buf( pit );
            for( int y = 0, p = 0; y < hei; ++y )
            {
                fread( &buf[0], components, wid, f );
                for( int x = 0; x < pit; x += components, ++p )
                {
                    t_color blue, green, red;
                    if( components == 1 )
                        blue = green = red = buf[x];
                    else
                    {   blue = buf[x + 0];
                        green = buf[x + 1];
                        red = buf[x + 2];
                    }// else if( components == 1 )
 
                    data[p] = red | ( green << 8 ) | ( blue << 16 ) | 0xff000000UL;
                }// for( int x = 0; x < pit; x += components, ++p )
            }// for( int y = 0, p = 0; y < hei; ++y )
            break;
        }
    case 4:
        {   fread( &data[0], sizeof( t_color ), img_size, f );
            break;
        }
 
    }// switch( components )
    res = true;
lExit:;
    if( f ) fclose( f );
    return res;
}
 
//записать изображение
bool lab07::h_tga_image::save( const char* img_name ) const
{
    bool res = false;
    s_tga_header header;
    if( data.empty() || !wid || !hei ) goto lExit;
 
    FILE* f = fopen( img_name, "wb" );
    if( !f ) goto lExit;
 
    header.color_type = TGA_NO_COLORMAP;
    header.image_type = TGA_TRUECOLOR;
 
    header.width = (t_word) wid;
    header.height = (t_word) hei;
    header.bpp = (t_byte) ( sizeof( t_color ) * 8 );
 
    fwrite( &header, sizeof( header ), 1, f );
    {
        t_colors temp_colors( data );
        for( t_colors::iterator i = temp_colors.begin(), e = temp_colors.end(); i != e; ++i )
            *i = win_color( *i ) | ( (*i) & 0xff000000UL );
 
 
        fwrite( &temp_colors[0], sizeof( t_color ), wid * hei, f );
    }
    res = true;
 
lExit:;
    if( f ) fclose( f );
    return res;
}
void lab07::s_imp_gray_scale::Process()
{
    if( IsEnd() ) return;
 
    int wid = src->width(), y = cur_y;
    for( int x = 0; x < wid; ++x )
    {
        t_color c = cur_pixel( x );
        int i = lum( c );
        result.set_pixel( x, y, color( i, i, i ) );
    }// for( int x = 0; x < wid; ++x )
 
    _add_op( wid );
    next();
}
 
void lab07::s_imp_sharp::Process()
{
    if( IsEnd() ) return;
 
    const int kernel_size = 8, sharp_level = 6;
    static const int offs[] =
    {
        -1, -1,  0, -1,  1, -1, 
        -1,  0,          1,  0, 
        -1,  1,  0,  1,  1,  1, 
    };
 
 
    int wid = src->width(), y = cur_y;
    for( int x = 0; x < wid; ++x )
    {
        t_color c = cur_pixel( x );
        int r = red( c ), g = green( c ), b = blue( c );
        int r1 = 0, g1 = 0, b1 = 0;
        for( int o = 0; o < kernel_size * 2; o += 2 )
        {   t_color c1 = src->pixel( x + offs[o + 0], y + offs[o + 1] );
            r1 += red( c1 ); g1 += green( c1 ); b1 += blue( c1 );
        }// for( int o = 0; o < kernel_size * 2; o += 2 )
 
        r += ( r * kernel_size - r1 ) / sharp_level;
        g += ( g * kernel_size - g1 ) / sharp_level;
        b += ( b * kernel_size - b1 ) / sharp_level;
 
        result.set_pixel( x, y, color( r, g, b ) );
    }// for( int x = 0; x < wid; ++x )
 
    _add_op( wid * 8 );
    next();
}
 
void lab07::s_imp_blur::Process()
{
    if( IsEnd() ) return;
 
    const int kernel_size = 8;
    static const int offs[] =
    {
        -1, -1,  0, -1,  1, -1, 
        -1,  0,          1,  0, 
        -1,  1,  0,  1,  1,  1, 
    };
 
 
    int wid = src->width(), y = cur_y;
    for( int x = 0; x < wid; ++x )
    {
        t_color c = cur_pixel( x );
        float sumw = 1.f;
        float r = red( c ) * sumw, g = green( c ) * sumw, b = blue( c ) * sumw;
        for( int o = 0; o < kernel_size * 2; o += 2 )
        {
            int ix = offs[o + 0], iy = offs[o + 1];
            t_color c1 = src->pixel( x + ix, y + iy );
            float w = 1.f / sqrtf( float( ix * ix + iy * iy ) );
            r += red( c1 ) * w; g += green( c1 ) * w; b += blue( c1 ) * w;
            sumw += w;
        }// for( int o = 0; o < kernel_size * 2; o += 2 )
 
        r /= sumw; g /= sumw; b /= sumw;
 
        result.set_pixel( x, y, color( int( r + 0.5f ), int( g + 0.5f ), int( b + 0.5f ) ) );
    }// for( int x = 0; x < wid; ++x )
 
    _add_op( wid * 8 );
 
    next();
}