通用图象文件读取类

len3d
//---------------------------------------------------------------------------------------------
typedef struct my_error_mgr {
    struct jpeg_error_mgr pub;
    jmp_buf setjmp_buffer;
} *my_error_ptr;

METHODDEF void my_error_exit (j_common_ptr cinfo) {
    my_error_ptr myerr = (my_error_ptr) cinfo->err;
    longjmp(myerr->setjmp_buffer, 1);
}

//Number of simultaneous live strings.
//Libtiff uses a large number of strings simultaneously in a dialog, so this method 
//was modified so that it iterates through a different number of buffers.

#define TIF_MAX_STRINGS            4
#define TIF_MAX_STRING_SIZE        256

//Declare this function as extern "C" so that the libtiff stuff can hook into it.

extern "C" TCHAR *GetString(int id)
{
    static int bufPos=0;
    static TCHAR buf[TIF_MAX_STRING_SIZE*TIF_MAX_STRINGS];
    TCHAR* ret;

    if( LoadString(NULL, id, buf+bufPos, TIF_MAX_STRING_SIZE) ) {
        ret = buf+bufPos;
        bufPos += TIF_MAX_STRING_SIZE;
        if( bufPos >= TIF_MAX_STRINGS*TIF_MAX_STRING_SIZE ) bufPos = 0;
        return ret;
    }
    return NULL;
}
//---------------------------------------------------------------------------------------------
void Eclinse::getExt(std::string & name)
{
    int    pos;
    if( (pos = (int) name.find_last_of(\'.\')) != name.npos ) {
        int    count = (int) name.length() - pos;
        if( count > 5 )
            count = 5;
        name = name.substr( pos, count );
        if( name[name.length() - 1] == \'\\\' )
            name = name.substr( 0, name.length() - 1 );
    }
}
//---------------------------------------------------------------------------------------------
ImageFile::ImageFile()
{
    fp            = NULL;
    width        = 0;
    height        = 0;
    width1        = 0;
    height1        = 0;
    component    = 0;
    ypos        = 0;
}
//---------------------------------------------------------------------------------------------
ImageFile::~ImageFile()
{
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetWidth() const
{
    return width;
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetHeight() const
{
    return height;
}
//---------------------------------------------------------------------------------------------
int ImageFile::GetComponent() const
{
    return component;
}
//---------------------------------------------------------------------------------------------
RAWImageFile::RAWImageFile()
{
    wb    = 0;
}
//---------------------------------------------------------------------------------------------
RAWImageFile::~RAWImageFile()
{
    Close();
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
    Close();

    if( (fp = fopen( name, "rb" )) == NULL )
        return false;

    fread( &w, sizeof(int), 1, fp );
    fread( &h, sizeof(int), 1, fp );
    fread( &c, sizeof(int), 1, fp );

    Close();
    return true;
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::Load(const char *name)
{
    Close();

    if( (fp = fopen( name, "rb" )) == NULL )
        return false;

    fread( &width, sizeof(int), 1, fp );
    fread( &height, sizeof(int), 1, fp );
    fread( &component, sizeof(int), 1, fp );

    if( component != 3 && component != 4 )
        return false;

    width1        = width - 1;
    height1        = height - 1;
    ypos        = 0;
    wb            = width * component;
    
    return true;
}
//---------------------------------------------------------------------------------------------
void RAWImageFile::Close()
{
    if( fp != NULL ) {
        fclose( fp );
        fp = NULL;
    }
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::MoveToLine(int y)
{
    if( fp == NULL || y < 0 || y >= height )
        return false;
    fseek( fp, y * wb, SEEK_SET );
    ypos = y;
    return true;
}
//---------------------------------------------------------------------------------------------
bool RAWImageFile::MoveToNextLine()
{
    if( fp == NULL || ypos == height1 )
        return false;
    fseek( fp, wb, SEEK_CUR );
    ++ ypos;
    return true;
}
//---------------------------------------------------------------------------------------------
void RAWImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
    if( fp == NULL )
        return;
    fseek( fp, x1 * component, SEEK_CUR );
    if( component == 3 ) {
        fread( BGRbuf, (x2 - x1) * component, 1, fp );
    } else if( component == 4 ) {
        for(int i = x1; i < x2; ++i) {
            fread( BGRbuf, 3, 1, fp );
            fread( Abuf, 1, 1, fp );
            BGRbuf += 3;
            ++ Abuf;
        }
    }
    fseek( fp, - x2 * component, SEEK_CUR );
}
//---------------------------------------------------------------------------------------------
BMPImageFile::BMPImageFile()
{
    wb    = 0;
}
//---------------------------------------------------------------------------------------------
BMPImageFile::~BMPImageFile()
{
    Close();
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
    Close();

    if( (fp = fopen( name, "rb" )) == NULL )
        return false;

    BITMAPFILEHEADER    bfhHeader;

    fread( &bfhHeader, sizeof(BITMAPFILEHEADER), 1, fp );

    if( bfhHeader.bfType != 0x4d42 ) {
        fclose( fp );
        return false;
    }

    UINT    uBmpInfoLen = (UINT) bfhHeader.bfOffBits - sizeof(BITMAPFILEHEADER);

    LPBITMAPINFOHEADER    m_lpBMPHdr = (LPBITMAPINFOHEADER) new BYTE [ uBmpInfoLen ];

    fread( m_lpBMPHdr, uBmpInfoLen, 1, fp );

    if( m_lpBMPHdr->biSize != sizeof(BITMAPINFOHEADER) ||
        m_lpBMPHdr->biBitCount != 24 ||
        m_lpBMPHdr->biCompression != BI_RGB ) {
        delete [] m_lpBMPHdr;
        fclose( fp );
        return false;
    }

    w = m_lpBMPHdr->biWidth;
    h = m_lpBMPHdr->biHeight;
    c = 4;

    delete [] m_lpBMPHdr;

    Close();
    return true;
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::Load(const char *name)
{
    Close();

    if( (fp = fopen( name, "rb" )) == NULL )
        return false;

    BITMAPFILEHEADER    bfhHeader;

    fread( &bfhHeader, sizeof(BITMAPFILEHEADER), 1, fp );

    if( bfhHeader.bfType != 0x4d42 ) {
        fclose( fp );
        return false;
    }

    UINT    uBmpInfoLen = (UINT) bfhHeader.bfOffBits - sizeof(BITMAPFILEHEADER);

    LPBITMAPINFOHEADER    m_lpBMPHdr = (LPBITMAPINFOHEADER) new BYTE [ uBmpInfoLen ];

    fread( m_lpBMPHdr, uBmpInfoLen, 1, fp );

    if( m_lpBMPHdr->biSize != sizeof(BITMAPINFOHEADER) ||
        m_lpBMPHdr->biBitCount != 24 ||
        m_lpBMPHdr->biCompression != BI_RGB ) {
        delete [] m_lpBMPHdr;
        fclose( fp );
        return false;
    }

    width        = m_lpBMPHdr->biWidth;
    height        = m_lpBMPHdr->biHeight;
    component    = 3;
    width1        = width - 1;
    height1        = height - 1;
    ypos        = height1;
    wb            = (width * 3 + 3) & ~3;

    delete [] m_lpBMPHdr;

    return true;
}
//---------------------------------------------------------------------------------------------
void BMPImageFile::Close()
{
    if( fp != NULL ) {
        fclose( fp );
        fp = NULL;
    }
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::MoveToLine(int y)
{
    if( fp == NULL || y < 0 || y >= height )
        return false;
    fseek( fp, 0, SEEK_END );
    fseek( fp, - wb * (y + 1), SEEK_CUR );
    ypos = y;
    return true;
}
//---------------------------------------------------------------------------------------------
bool BMPImageFile::MoveToNextLine()
{
    if( fp == NULL || ypos == height1 )
        return false;
    fseek( fp, - wb, SEEK_CUR );
    ++ ypos;
    return true;
}
//---------------------------------------------------------------------------------------------
void BMPImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
    if( fp == NULL )
        return;
    fseek( fp, x1 * component, SEEK_CUR );
    fread( BGRbuf, (x2 - x1) * component, 1, fp );
    fseek( fp, - x2 * component, SEEK_CUR );
}
//---------------------------------------------------------------------------------------------
JPGImageFile::JPGImageFile()
{
}
//---------------------------------------------------------------------------------------------
JPGImageFile::~JPGImageFile()
{
    Close();
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
    Close();

    if( (fp = fopen( name, "rb" ) ) == NULL )
        return false;

    struct jpeg_decompress_struct    cinfo;
    struct my_error_mgr                jerr;

    cinfo.err = jpeg_std_error( &jerr.pub );
    jerr.pub.error_exit = my_error_exit;

    if( setjmp(jerr.setjmp_buffer) ) {
        jpeg_destroy_decompress( &cinfo );
        return false;
    }

    jpeg_create_decompress( &cinfo );
    jpeg_stdio_src( &cinfo, fp );

    jpeg_read_header( &cinfo, TRUE );
    jpeg_start_decompress( &cinfo );

    if( cinfo.num_components != 3 && cinfo.num_components != 4 )
        return false;

    w = cinfo.output_width;
    h = cinfo.output_height;
    c = cinfo.num_components;

    jpeg_destroy_decompress( &cinfo );

    Close();
    return true;
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::Load(const char *name)
{
    Close();

    if( (fp = fopen( name, "rb" ) ) == NULL )
        return false;

    struct jpeg_decompress_struct    cinfo;
    struct my_error_mgr                jerr;
    JSAMPARRAY                        buffer;
    int                                row_stride;
    FILE                            *tmpf = NULL;

    cinfo.err = jpeg_std_error( &jerr.pub );
    jerr.pub.error_exit = my_error_exit;

    if( setjmp(jerr.setjmp_buffer) ) {
        jpeg_destroy_decompress( &cinfo );
        return false;
    }

    jpeg_create_decompress( &cinfo );
    jpeg_stdio_src( &cinfo, fp );

    jpeg_read_header( &cinfo, TRUE );
    jpeg_start_decompress( &cinfo );

    if( cinfo.num_components != 3 && cinfo.num_components != 4 )
        return false;

    width        = cinfo.output_width;
    height        = cinfo.output_height;
    component    = cinfo.num_components;
    width1        = width - 1;
    height1        = height - 1;
    ypos        = 0;
    row_stride    = width * component;

    buffer = (*cinfo.mem->alloc_sarray)
                ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);

    tmpnam( tmpf_name );
    
    if( (tmpf = fopen(tmpf_name, "wb")) == NULL ) {
        jpeg_destroy_decompress( &cinfo );
        return false;
    }

    fwrite( &width, sizeof(int), 1, tmpf );
    fwrite( &height, sizeof(int), 1, tmpf );
    fwrite( &component, sizeof(int), 1, tmpf );

    while( cinfo.output_scanline < cinfo.output_height ) {
        jpeg_read_scanlines( &cinfo, buffer, 1 );
        BYTE    *ptr = buffer[0];
        if( component == 3 ) {
            for(int i = 0; i < width; ++i) {
                fwrite( ptr + 2, 1, 1, tmpf );
                fwrite( ptr + 1, 1, 1, tmpf );
                fwrite( ptr + 0, 1, 1, tmpf );
                ptr += component;
            }
        } else if( component == 4 ) {
            for(int i = 0; i < width; ++i) {
                fwrite( ptr + 2, 1, 1, tmpf );
                fwrite( ptr + 1, 1, 1, tmpf );
                fwrite( ptr + 0, 1, 1, tmpf );
                fwrite( ptr + 3, 1, 1, tmpf );
                ptr += component;
            }
        }
    };

    fclose( tmpf );

    jpeg_finish_decompress( &cinfo );
    jpeg_destroy_decompress( &cinfo );

    raw.Load( tmpf_name );

    return true;
}
//---------------------------------------------------------------------------------------------
void JPGImageFile::Close()
{
    if( fp != NULL ) {
        fclose( fp );
        fp = NULL;
    }
    raw.Close();
    remove( tmpf_name );
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::MoveToLine(int y)
{
    return raw.MoveToLine( y );
}
//---------------------------------------------------------------------------------------------
bool JPGImageFile::MoveToNextLine()
{
    return raw.MoveToNextLine();
}
//---------------------------------------------------------------------------------------------
void JPGImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
    raw.FormatSubLine( BGRbuf, Abuf, x1, x2 );
}
//---------------------------------------------------------------------------------------------
TIFImageFile::TIFImageFile()
{
    tif        = NULL;
    td        = NULL;
    loadbuf    = NULL;
}
//---------------------------------------------------------------------------------------------
TIFImageFile::~TIFImageFile()
{
    Close();
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::GetInfo(const char *name, int & w, int & h, int & c)
{
    Close();

    if( (tif = TIFFOpen( name, _T("r") )) == NULL )
        return false;

    td = &tif->tif_dir;

    if( td->td_photometric != PHOTOMETRIC_RGB ||
        (td->td_samplesperpixel != 3 && td->td_samplesperpixel != 4) ||
        td->td_bitspersample != 8 )
        return false;

    w = td->td_imagewidth;
    h = td->td_imagelength;
    c = td->td_samplesperpixel;

    Close();
    return true;
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::Load(const char *name)
{
    Close();

    if( (tif = TIFFOpen( name, _T("r") )) == NULL )
        return false;

    td = &tif->tif_dir;

    if( td->td_photometric != PHOTOMETRIC_RGB ||
        (td->td_samplesperpixel != 3 && td->td_samplesperpixel != 4) ||
        td->td_bitspersample != 8 )
        return false;

    width        = td->td_imagewidth;
    height        = td->td_imagelength;
    component    = td->td_samplesperpixel;
    width1        = width - 1;
    height1        = height - 1;
    ypos        = 0;
    
    loadbuf = new BYTE[ tif->tif_scanlinesize ];

    return true;
}
//---------------------------------------------------------------------------------------------
void TIFImageFile::Close()
{
    if( tif != NULL ) {
        TIFFClose( tif );
        tif    = NULL;
        td    = NULL;
    }
    if( loadbuf != NULL ) {
        delete [] loadbuf;
        loadbuf = NULL;
    }
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::MoveToLine(int y)
{
    if( tif == NULL || y < 0 || y >= height )
        return false;
    ypos = y;
    return true;
}
//---------------------------------------------------------------------------------------------
bool TIFImageFile::MoveToNextLine()
{
    if( tif == NULL || ypos == height1 )
        return false;
    ++ ypos;
    return true;
}
//---------------------------------------------------------------------------------------------
void TIFImageFile::FormatSubLine(BYTE *BGRbuf, BYTE *Abuf, int x1, int x2)
{
    if( tif == NULL )
        return;
    BYTE    *dst, *ptr;
    if( td->td_planarconfig == PLANARCONFIG_SEPARATE ) {
        for(int i = 0; i < 3; ++i) {
            TIFFReadScanline( tif, loadbuf, ypos, 2 - i );
            dst = BGRbuf + i,
            ptr = loadbuf + x1;
            for(int x = x1; x < x2; ++x) {
                dst[0] = ptr[0];
                dst += 3;
                ++ ptr;
            }
        }
        if( component == 4 ) {
            TIFFReadScanline( tif, loadbuf, ypos, 3 );
            dst = Abuf;
            ptr = loadbuf + x1;
            for(int x = x1; x < x2; ++x) {
                dst[0] = ptr[0];
                ++ dst;
                ++ ptr;
            }
        }
    } else {
        TIFFReadScanline( tif, loadbuf, ypos, 0 );
        ptr = loadbuf + x1 * component;
        if( component == 3 ) {
            for(int i = x1; i < x2; ++i) {
                BGRbuf[0]    = ptr[2];
                BGRbuf[1]    = ptr[1];
                BGRbuf[2]    = ptr[0];
                BGRbuf += 3;
                ptr += component;
            }
        } else if( component == 4 ) {
            for(int i = x1; i < x2; ++i) {
                BGRbuf[0]    = ptr[2];
                BGRbuf[1]    = ptr[1];
                BGRbuf[2]    = ptr[0];
                Abuf[0]        = ptr[3];
                BGRbuf += 3;
                ++ Abuf;
                ptr += component;
            }
        }
    }
}
//---------------------------------------------------------------------------------------------

分类：

技术点：

相关文章：

  • 2021-10-31
  • 2022-12-23
  • 2021-11-17
  • 2021-10-07
  • 2021-11-19
  • 2022-12-23
  • 2021-11-23
猜你喜欢
  • 2021-07-03
  • 2022-12-23
  • 2021-09-25
  • 2021-07-13
  • 2022-12-23
  • 2021-05-22
  • 2022-12-23
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode