TIFF文件解析

最新推荐文章于 2024-08-15 20:21:00 发布
最新推荐文章于 2024-08-15 20:21:00 发布
阅读量7.2k 收藏 30
点赞数 5
分类专栏： GIS相关 文章标签： gis tiff c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wb175208/article/details/60607852
版权

  TIF文件是一种标签标记文件，为什么这么说呢？它的文件的构成方式就是根据Tag来标记的。同时还可以记录地理信息，坐标、投影等信息，非常方便在GIS领域使用。网上关于TIFF文件的介绍也是不少，今天我主要是把我之前使用C++解析TIF文件的过程记录下来。
1.定义TIFF文件的结构体

//TIFF文件的数据结构
typedef struct 
{
    FILE* pfile;                     //tiff文件
    TIFF_UINT16_T tiff_byte_order;   //字节序   
    TIFF_UINT16_T tiff_version;      //文件版本
    TIFF_UINT32_T tiff_dir_off;      //DE位置
    long tif_width;                  //宽度
    long tif_height;                 //高度
    long compression;                //压缩 1:不压缩
    long photo_metric_inter;         //图像的色彩模式 2:RGB  3:索引图片
    long bit_per_samples ;           //像素的分量值
    long samples_per_pixel;          //每个象素的通道数
    long rows_per_strip;             //每个扫描行的图像数据行数
    long bcount_strip_offset;        //多少条扫描行
    long planar_config;              //图像数据存储方式 1 - RGBRGBRGB 2 - RRRGGGBBB
    TIFF_UINT32_T* strip_line;       //扫描行的起始位置
    long bcount_strip_byte_counts;   //
    TIFF_UINT32_T* strip_byte_counts;//每条扫描行的字节数目
    TIFF_UINT16_T* color_map;        //颜色表
    Tile tile;                       //瓦片数据
    GeoTiff geo_tiff;                //GeoTiff文件头
}TiffFile;

2.定义在这个过程中使用到的宏

#define TIFF void*


#define TIFF_VERSION_CLASSIC 42
#define TIFF_BIGENDIAN      0x4d4d
#define TIFF_LITTLEENDIAN   0x4949

#define PI 3.14159265358979323846

#define SIZEOF_INT 4

/* Signed 8-bit type */
#define TIFF_INT8_T signed char

/* Unsigned 8-bit type */
#define TIFF_UINT8_T unsigned char

/* Signed 16-bit type */
#define TIFF_INT16_T signed short

/* Unsigned 16-bit type */
#define TIFF_UINT16_T unsigned short

/* Signed 32-bit type formatter */
#define TIFF_INT32_FORMAT "%d"

/* Signed 32-bit type */
#define TIFF_INT32_T signed int

/* Unsigned 32-bit type */
#define TIFF_UINT32_T unsigned int


/* Signed 64-bit type */
#define TIFF_INT64_T signed __int64

/* Unsigned 64-bit type formatter */
#define TIFF_UINT64_FORMAT "%I64u"

/* Unsigned 64-bit type */
#define TIFF_UINT64_T unsigned __int64

/* Signed size type */
#if defined(_WIN64)
#define TIFF_SSIZE_T signed __int64
#else
#define TIFF_SSIZE_T signed int
#endif

/* Signed size type formatter */
#if defined(_WIN64)
#define TIFF_SSIZE_FORMAT "%I64d"
#else
#define TIFF_SSIZE_FORMAT "%ld"
#endif

/* Pointer difference type */
#define TIFF_PTRDIFF_T long

#define TIFF_ERROR_PATH_SUCCESS    0 
#define TIFF_ERROR_PATH_NULL       -1
#define TIFF_ERROR_OPEN_FAILED     -2
#define TIFF_ERROR_BYTE_ORDER      -3
#define TIFF_ERROR_TIFF_VER        -4

如果里面使用到地理信息还会使用到以下定义：

#define TIFF_GEO_GeoTagPixelScale   33550
#define TIFF_GEO_GeoTagTiePoint     33922
#define TIFF_GEO_GeoTagTransMatrix  34264
#define TIFF_GEO_GeoTagDirectory    34735
#define TIFF_GEO_GeoTagDoubleParams 34736
#define TIFF_GEO_GeoTagASCIIParams  34737

3.首先打开TIFF文件

int tif_open( const char* tiff_path , TiffFile* tf)
{
    if ( tiff_path == NULL)
    {
        return -1;
    }

    //打开文件
    FILE* ptiff = fopen( tiff_path , "rb" );
    if ( ptiff == NULL )
    {
        return -2;
    }
    tf->pfile = ptiff;

    fseek( ptiff ,0 ,SEEK_CUR );

    //得到字节序
    TIFF_UINT16_T byte_order;
    fread( &byte_order,1 , 2,ptiff );

    tf->tiff_byte_order = byte_order;

    if ( !((byte_order ==TIFF_BIGENDIAN) || (byte_order ==TIFF_LITTLEENDIAN)) )
    {
        fclose( ptiff );
        return -3;
    }

    TIFF_UINT8_T s[2]={0};


    //得到TIFF版本
    fread( s ,2 , 1, ptiff );
    TIFF_INT16_T byte_ver = sget2(s,byte_order);

    tf->tiff_version = byte_ver;

    if ( TIFF_VERSION_CLASSIC !=byte_ver )
    {
        fclose( ptiff );
        return -4;
    }

    //得到IFD的文件偏移量
    TIFF_UINT32_T IFDoffset = get4( ptiff , byte_order );

    tf->tiff_dir_off = IFDoffset;


    fseek( ptiff , IFDoffset-8 ,SEEK_CUR );

    //得到IFD的数量
    TIFF_UINT16_T IFDnum = get2( ptiff , byte_order );

    int fs = fseek( ptiff ,2+IFDoffset , SEEK_SET );

    TIFF_UINT16_T tdir_tag = 0 , tdir_type = 0 ;
    TIFF_UINT32_T tdir_count = 0 , toff_long = 0 ;
    for (TIFF_UINT16_T i=0x0000;i< IFDnum ;i++)
    {
        TIFF_UINT32_T file_offset = 2+IFDoffset+12*i;
        int fs = fseek( ptiff , 2+IFDoffset+12*i , SEEK_SET );

        tdir_tag = get2( ptiff , byte_order );

        if ( tdir_tag == 0x100 )//width
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );

            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }


            tf ->tif_width = toff_long ;
            continue;
        }
        else if ( tdir_tag == 0x101 )//height
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );


            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }

            tf ->tif_height = toff_long ;
            continue;
        }
        else if ( tdir_tag == 0x102 )//BitsPerSample
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            if ( tdir_count == 1 )
            {
                if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
                {
                    toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
                }
                else
                {
                    toff_long = get4( ptiff , byte_order );
                }
                tf -> bit_per_samples = toff_long ;
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
                TIFF_UINT16_T* sl = (TIFF_UINT16_T*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(TIFF_UINT16_T) );
                TIFF_UINT16_T* s2 = sl;
                for ( int i = 0 ; i < (int)tdir_count ; i++ )
                {
                    TIFF_UINT32_T s16 = sget2((TIFF_UINT8_T*)(s2 + i) , tf->tiff_byte_order );
                    tf -> bit_per_samples += s16 ;
                }
            }


            continue;
        }
        else if ( tdir_tag == 0x103 )//Compression
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }
            tf ->compression = toff_long ;
            continue;
        }
        else if ( tdir_tag == 0x106 )//PhotometricInterpretation
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }
            tf ->photo_metric_inter = toff_long ;
            continue;
        }
        else if ( tdir_tag == 0x111 )//StripOffsets
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->bcount_strip_offset = tdir_count ;
            if ( tdir_count > 1 )
            {
                TIFF_UINT32_T* sl = (TIFF_UINT32_T*)get_byte_mem( ptiff , toff_long , tdir_count * sizeof(TIFF_UINT32_T) );

                TIFF_UINT32_T* sl2 = sl;

                //字节序的转换
                for ( int i = 0 ; i < (int)tdir_count ; i++ )
                {
                    TIFF_UINT32_T s32 = sget4((TIFF_UINT8_T*)sl2 , tf->tiff_byte_order );
                    memcpy( sl2 , &s32 , 4 );
                    sl2+=1;
                }
                tf ->strip_line = sl ;
            }
            else
            {
                tf ->bcount_strip_offset = 1;
                tf ->strip_line = new TIFF_UINT32_T;
                *(tf ->strip_line) = toff_long;
            }
            continue;
        }
        else if ( tdir_tag == 0x115 )//SamplesPerPixel
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }
            tf ->samples_per_pixel = toff_long ;
            continue;
        }
        else if ( tdir_tag == 0x116 )//RowsPerStrip
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }
            tf ->rows_per_strip = toff_long;
            continue;
        }
        else if ( tdir_tag == 0x117 )//StripByteCounts
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->bcount_strip_byte_counts = tdir_count ;

            if ( tf ->bcount_strip_byte_counts > 1 )
            {
                TIFF_UINT32_T* sl = (TIFF_UINT32_T*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(TIFF_UINT32_T) );

                TIFF_UINT32_T* sl2 = sl;

                //字节序的转换
                for ( int i = 0 ; i < (int)tdir_count ; i++ )
                {
                    TIFF_UINT32_T s32 = sget4((TIFF_UINT8_T*)sl2 , tf->tiff_byte_order );
                    memcpy( sl2 , &s32 , 4 );
                    sl2+=1;
                }
                tf ->strip_byte_counts = sl ;
            }
            else
            {
                tf ->bcount_strip_byte_counts = 1;
                tf ->strip_byte_counts = new TIFF_UINT32_T;
                *(tf ->strip_byte_counts) = toff_long;
            }
            continue;
        }
        else if ( tdir_tag == 0x11c )//Planar Configuration
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );

            if ( ( tdir_type == 3 || tdir_type == 4 ) && byte_order == 0x4d4d/*Motor*/ && tdir_count == 1 )
            {
                toff_long = (TIFF_UINT32_T)get2( ptiff , byte_order );
            }
            else
            {
                toff_long = get4( ptiff , byte_order );
            }

            tf->planar_config = toff_long ;
            continue;
        }
        else if ( tdir_tag== 0x140 )//Color map
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            int pow1 = 0;
            if ( tf ->bit_per_samples == 1 )
            {
                pow1 = 1<<1;
            }
            else if ( tf ->bit_per_samples == 4 )
            {
                pow1 = 1<<4;
            }
            else if ( tf ->bit_per_samples == 8 )
            {
                pow1 = 1<<8;
            }

            tf ->color_map = (TIFF_UINT16_T*)get_byte_mem( ptiff , toff_long , 3*pow1*2 );

        }
        else if ( tdir_tag== 0x142 )//tile width
        {
            tf ->tile.is_tile = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->tile.tile_width = toff_long ;
            continue;
        }
        else if ( tdir_tag== 0x143 )//tile height
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->tile.tile_height = toff_long ;
            continue;
        }
        else if ( tdir_tag== 0x144 )//tile offset
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->tile.tile_offset_count = tdir_count ;

            if ( tdir_count > 1 )
            {
                tf ->tile.tile_offset_list = (TIFF_UINT32_T*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(TIFF_UINT32_T) );
            }

            continue;
        }
        else if ( tdir_tag== 0x145 )//tile byte count
        {
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf ->tile.tile_byte_num_count = tdir_count ;

            if ( tdir_count > 1 )
            {
                tf ->tile.tile_byte_num_list = (TIFF_UINT32_T*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(TIFF_UINT32_T) );
            }

            continue;
        }
        else if ( tdir_tag == 33550 ) //ModelPixelScaleTag
        {
            tf -> geo_tiff.is_geotiff = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );
            if ( tdir_count == 3 && tdir_type == 12 )
            {
                TIFF_UINT8_T* ps = (TIFF_UINT8_T*)get_byte_mem( ptiff , toff_long , tdir_count*8*sizeof(TIFF_UINT8_T) );
                tf -> geo_tiff.pixel_scale.scaleX = long_to_double( sget8( ps , byte_order)) ;
                tf -> geo_tiff.pixel_scale.scaleY = long_to_double( sget8( ps + 8 , byte_order)) ;
                tf -> geo_tiff.pixel_scale.scaleZ = long_to_double( sget8( ps + 16 , byte_order)) ;

                delete[] ps;
                ps = NULL;
            }
            continue;
        }
        else if ( tdir_tag == 33922 ) //ModelTiePointTag
        {
            tf -> geo_tiff.is_geotiff = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            if ( tdir_type == 12 && tdir_count >= 6 )
            {
                TIFF_UINT8_T* ps = (TIFF_UINT8_T*)get_byte_mem( ptiff , toff_long , tdir_count*8*sizeof(TIFF_UINT8_T) );

                tf -> geo_tiff.tie_point.SrcX = long_to_double( sget8( ps , byte_order)) ;
                tf -> geo_tiff.tie_point.SrcY = long_to_double( sget8( ps +8 , byte_order)) ;
                tf -> geo_tiff.tie_point.SrcZ = long_to_double( sget8( ps + 16 , byte_order)) ;

                tf -> geo_tiff.tie_point.DecX = long_to_double( sget8( ps + 24, byte_order)) ;
                tf -> geo_tiff.tie_point.DecY = long_to_double( sget8( ps + 32 , byte_order)) ;
                tf -> geo_tiff.tie_point.DecZ = long_to_double( sget8( ps + 40 , byte_order)) ;

                delete[] ps;
                ps = NULL;
            }

            continue;
        }
        else if ( tdir_tag == 34735 ) //GeoKeyDirectoryTag
        {
            tf -> geo_tiff.is_geotiff = true ;
            tf -> geo_tiff.is_geokeys = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf -> geo_tiff.geo_tag_directory = (TIFF_UINT16_T*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(TIFF_UINT16_T) );
            continue;
        }
        else if ( tdir_tag == 34736 ) //GeoDoubleParamsTag
        {
            tf -> geo_tiff.is_geotiff = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );

            tf -> geo_tiff.double_param_count = tdir_count ;

            tf -> geo_tiff.geo_double = (double*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(double) );
            continue;
        }
        else if ( tdir_tag == 34737 ) //GeoAsciiParamsTag
        {
            tf -> geo_tiff.is_geotiff = true ;
            tdir_type = get2( ptiff , byte_order );
            tdir_count = get4( ptiff , byte_order );
            toff_long = get4( ptiff , byte_order );
            tf -> geo_tiff.ascii_param_count = tdir_count ;

            tf -> geo_tiff.geo_ascii = (char*)get_byte_mem( ptiff , toff_long , tdir_count*sizeof(char) );

            break;
        }
    }
    return 0;
}

4.TIFF文件在存储的图形数据有两种存储方式：一种是线性存储的，一种是块状存储的。在读取不同的数据结构时也是有不同的。
读取线性数据：

int read_tiff_file( int view_w ,int view_h , double sca , TiffFile* tiff_file , TIFF_UINT8_T* pbuf )
{
    double sc = 1 / sca ;//目标文件相对于源文件放大的倍数

    FILE *pfile = tiff_file->pfile;
    int  samples_per_pixel = tiff_file->samples_per_pixel;
    TIFF_UINT32_T* line_start = tiff_file->strip_line ;
    int SrcWidth = tiff_file->tif_width;

    for ( int i = view_h-1; i >=0 ; i-- )//上下颠倒
    {
        //选取最邻近的点
        int tSrcH = (int)( sc * i + 0.5);
        for ( int j = 0; j < view_w; j++)
        {
            int tSrcW = (int)( sc * j + 0.5);    
            fseek ( pfile , line_start[tSrcH] + tSrcW * samples_per_pixel  , SEEK_SET );
            fread( pbuf ,samples_per_pixel  ,1 , pfile );
            TIFF_UINT8_T u;
            u = pbuf[0];       //************//
            pbuf[0] = pbuf[2]; // BGR -> RGB //
            pbuf[2] = u;       //************//
            pbuf += 4/*samples_per_pixel*/;  
        }
    } 

    return 0;
}

读取块状数据：

int read_tile_tiff_file( int view_w ,int view_h , double sca , TiffFile* tiff_file , TIFF_UINT8_T* pbuf )
{
    FILE *pfile = tiff_file->pfile;
    int  samples_per_pixel = tiff_file->samples_per_pixel;
    TIFF_UINT32_T* line_start = tiff_file->strip_line ;
    int SrcWidth = tiff_file->tif_width;

    double sc = 1 / sca ;//目标文件相对于源文件放大的倍数
    TIFF_UINT32_T*tile_offset = tiff_file->tile.tile_offset_list;   //偏移量列表
    int pos_h = 0 ,pos_w = 0;
    int table_w = (int)( tiff_file->tif_width/ tiff_file->tile.tile_width);
    if ( tiff_file->tif_width% tiff_file->tile.tile_width > 0 )
    {
        table_w ++ ;
    }
    int table_h = (int)( tiff_file->tif_height/ tiff_file->tile.tile_height)+1;

    if (  tiff_file->tif_height% tiff_file->tile.tile_height > 0 )
    {
        table_h ++ ;
    }

    int tile_H = tiff_file->tile.tile_height ;
    int tile_W = tiff_file->tile.tile_width ;
    //for ( int i = 0 ; i< desH ; i ++ )
    for ( int i = view_h-1 ; i >= 0 ; i -- )
    {
        int tSrcH = (int)( sc * i + 0.5);
        pos_h = tSrcH / tile_H;
        for ( int j = 0 ; j < view_w ; j ++ )
        {
            int tSrcW = (int)( sc * j + 0.5);    
            pos_w  = tSrcW / tile_W;
            TIFF_UINT32_T file_offset_start = tile_offset[ pos_h*table_w + pos_w ];

            to_client( tSrcW , tSrcH , tile_W , tile_H );

            fseek ( pfile , file_offset_start+(tSrcH*tile_W+ tSrcW)*samples_per_pixel, SEEK_SET );
            fread( pbuf ,samples_per_pixel  ,1 , pfile );
            TIFF_UINT8_T u;
            u = pbuf[0];       //************//
            pbuf[0] = pbuf[2]; // BGR -> RGB //
            pbuf[2] = u;       //************//
            pbuf += 4/*samples_per_pixel*/;  
        }
    }
    return 0;
}

5.如果TIFF中包含地理信息，还需要把地理信息取出来

//通过像素坐标的范围确定地理坐标的范围
void geo_coord( TiffFile* tf , geoRECT pixel_rect , geoRECT&geoRect )
{
    geoRect.left = tf->geo_tiff.tie_point.DecX + ( pixel_rect.left - tf->geo_tiff.tie_point.SrcX ) * tf->geo_tiff.pixel_scale.scaleX ;
    geoRect.top = tf->geo_tiff.tie_point.DecY + ( pixel_rect.top - tf->geo_tiff.tie_point.SrcY ) * tf->geo_tiff.pixel_scale.scaleY ;
    geoRect.right = tf->geo_tiff.tie_point.DecX + ( pixel_rect.right - tf->geo_tiff.tie_point.SrcX ) * tf->geo_tiff.pixel_scale.scaleX ;
    geoRect.botton = tf->geo_tiff.tie_point.DecY - ( pixel_rect.botton - tf->geo_tiff.tie_point.SrcY ) * tf->geo_tiff.pixel_scale.scaleY ;
}

6.最后，如果是Google投影，则不需要proj4来转换，直接使用以下函数就可以实现地理坐标新（WGS84）和Google投影之间的坐标转换

#define PI 3.14159265358979323846

void web_mercator_2_lonlat( coordPairs&ml )
{
    ml.x = ml.x / 20037508.3427892 * 180;
    double y = ml.y / 20037508.3427892 * 180;
    ml.y = 180 / PI * ( 2 * atan ( exp ( y * PI / 180 ) ) - PI / 2 );
}

void lonlat_2_web_mercator( coordPairs&ml )
{
    ml.x = ml.x * 20037508.3427892 / 180;
    double y = log ( tan ( ( 90 + ml.y ) * PI / 360 ) ) / ( PI / 180 );
    ml.y = y * 20037508.3427892 / 180;
}

好了，以上是读取TIFF文件的主要内容
源码下载

wb175208
关注
专栏目录
tiff格式的分析
m0_46340275的博客
03-29 512
文件结构 tiff文件中的关键词是：文件头，文件目录，目录项。 文件头 文件头通常8Byte 0-1B：49 49或4D 4D，前者表示小字节在前，后者表示大字节在前 2-3B：一般为42，是标志位 4-7B:第一个文件目录的偏移量，必须是2的整数倍 文件目录 0-1B:该文件目录包含的目录项的个数 从2B开始：目录项，每个目录项占12B 最后4B：下一个文件目录的偏移量，0表示没有下一个 目录项...
[数据压缩作业2]TIFF文件格式分析
m0_59620643的博客
04-13 1056
目录 一. PNG概述 一. TIFF概述 TIFF是Tagged Image File Format的缩写。在现在的标准中，只有TIFF存在， 其他的提法已经舍弃不用了。做为一种标记语言，TIFF与其他文件格式最大的不同在于除了图像数据，它还可以记录很多图像的其他信息。它记录图像数据的方式也比较灵活， 理论上来说， 任何其他的图像格式都能为TIFF所用， 嵌入到TIFF里面。比如JPEG， Lossless JPEG， JPEG2000和任意数据宽度的原始无压缩数据都可以方便的嵌入到TIFF中去
C#处理tif文件
12-11
VS2010下 C#处理tif文件，可以对tif文件进行分割，合并(tif,jpg等单个文件合并成一个tif文件)，查看tif文件里各个文件的属性，有代码，而且比较简单。因为是随笔，所以下载的同学需要看研究一下代码才能有效使用。
TIFF图像文件格式解析
weixin_44874766的博客
03-20 8184
TIFF 6.0 Specification下载链接 文章目录1TIFF文件格式概述2 TIFF格式解析2.1 图像文件头（Image File Header,IFH）2.2 图像文件目录（Image File Directory,IFD）2.3 目录项（Directory Entry,DE）2.4 图像数据2.5 上述数据的排列顺序3 实例分析3.1 整体概览3.2 IFH分析3.3 接下来是大量的图像数据3.4 第一个(也是最后一个)IFD3.5 10个DE4 问题和总结5 参考文献和资料 1TIFF文
ArcGIS Pro 实现人口分布栅格TIFF数据的网格提取与可视化
最新发布
weixin_45812624的博客
08-15 1993
本文介绍了如何使用ArcGIS Pro将LandScan提供的1公里精度的全球人口分布栅格数据（TIFF格式）提取到网格并进行可视化。LandScan是由美国能源部橡树岭国家实验室提供的全球人口分布数据集，具有30弧秒（约1公里）的空间分辨率。通过ArcGIS Pro，首先建立了1公里×1公里的渔网，接着对渔网进行了两次裁剪以匹配上海市行政区划。随后，将人口分布栅格数据裁剪并与渔网进行关联，最后通过自然间断分级法对人口数据进行分级展示，实现了人口分布的可视化分析。
C#读取TIFF文件
qq_16555407的博客
03-09 8768
1 什么是TIFF？ TIFF是Tagged Image File Format的缩写。在现在的标准中，只有TIFF存在， 其他的提法已经舍弃不用了。做为一种标记语言，TIFF与其他文件格式最大的不同在于除了图像数据，它还可以记录很多图像的其他信息。它记录图像数据的方式也比较灵活， 理论上来说， 任何其他的图像格式都能为TIFF所用， 嵌入到TIFF里面。比如JPEG， Lossless JP...
C#对tiff文件操作类
04-20
winForm程序选择tiff文件后，对tiff文件进行拆分，将拆分后的矩阵展示在窗口中，可以拆分多个tiff文件展示在窗口，点击合并后，将所有展示的图片合并成新的tiff文件并输出到本地
GeotiffParser（tiff格式数据解析器）
08-04
TIFF解析器不仅要理解TIFF文件的结构，包括图像的宽高、色彩模式、压缩方式等基本信息，还需要处理与地理信息系统相关的元数据，如地理坐标系统、投影方式等，确保解析后的数据能够正确地反映其地理空间位置。...
VC++解析TIFF格式文件库
04-13
使用libtiff进行TIFF文件解析的基本步骤如下： 1. **安装库**：下载并编译libtiff源代码，确保生成适用于VC++的库文件（.lib）和头文件（.h）。这通常涉及到配置Visual Studio项目设置，指向库和头文件的位置。 2....
tiff-js:TIFF图像格式的基于JavaScript的解析器
05-14
1. **解析TIFF文件结构**：`tiff-js`能够解析TIFF文件的头部信息，识别IFD（Image File Directory）结构，每个IFD包含图像的元数据，如宽度、高度、位深度、压缩方法等。 2. **处理TIFF标签**：TIFF文件中的每个...
C#读取tif格式图片
04-27
c#语言实现tif格式的图片的显示及读取属性信息 具有可视化界面
TIFF的C++库
04-16
C++语言的TIFF类库，包含32位和64位。可以用于创建、打开TIFF格式的图像。
操作tiff文件的帮助类
01-27
对图像文件的操作 ，主要功能有：多张图片合并成一个tiff文件、将tiff文件的拆分成多张图片以及多个tiff文件合并成一个tiff文件
TIFF图像文件格式分析
weixin_45847421的博客
03-25 6379
TIFF图像文件格式分析一、TIFF图像文件格式概述1、TIFF的简介2、TIFF的局限及将来发展二、TIFF文件结构1、IFH的构成2、IFD的构成(0代表此IFD的起始位置)3、DE的构成 一、TIFF图像文件格式概述 1、TIFF的简介 TIFF是Tagged Image File Format的缩写，为标签图像文件格式，是一种灵活的位图格式，主要用来存储包括照片和艺术图在内的图像。最初由Aldus公司与微软公司一起为PostScript打印开发。TIFF与JPEG和PNG一起成为流行的高位彩色图像格
解析tif文件
透明
06-30 2653
https://www.cnblogs.com/Romi/archive/2012/03/14/2396627.html GDAL库——读取图像并提取基本信息 Posted on2012-03-14 21:31romi 阅读(19408) 评论(1)编辑收藏 GDAL库是一个跨平台的栅格地理数据格式库，包括读取、写入、转换、处理各种栅格数据格式（有些特定的格式对一些操作如写入等不支持）。它使用了一个单一的抽象数据模型就支持了大多数的栅格数据。这里有GDAL库支持的格式：h...
【基础知识】tiff格式图片介绍及读取
热门推荐
All_In_gzx_cc的博客
10-20 3万+
TIFF格式也叫TIF，属于位图格式，全名是。TIFF格式和JPEG及PNG都是属于一种主流且高位彩色图像格式。使用过扫描仪或传真的小伙伴应该还记得，很多品牌及其默认文件就是.tiff后缀。因为TIFF最初的设计目的就是在1980年左右，扫描仪厂商达成一个公用的统一的扫描图像文件格式，而不是每个厂商使用自己专有的格式造成混乱。TIFF是一种比较灵活的图像格式，它的全称是Tagged Image File Format，文件扩展名为TIF或 TIFF。
TIF图像文件的读取（c++代码）
数学屌丝走在it的道路上
10-04 2万+
一 TIF图像介绍     TIFF是最复杂的一种位图文件格式。TIFF是基于标记的文件格式，它广泛地应用于对图像质量要求较高的图像的存储与转换。由于它的结构灵活和包容性大，它已成为图像文件格式的一种标准，绝大多数图像系统都支持这种格式。    TIFF 是一个灵活适应性强的文件格式，通过在文件头中包含“标签”它能够在一个文件中处理多幅图像和数据。标签能够标明图像的如图像大小这样的基本几何尺寸
TIFF图像格式解析
m1m2m3mmm的博客
10-31 4771
TIFF图像格式解析及opencv读取16位TIFF图像示例程序
C++读取TIFF文件代码实现与解析
在读取TIFF文件时，程序需要遍历IFD的每个条目，解析其内容并根据需要解码图像数据。例如，ImageWidth（标签256）和ImageLength（标签257）分别指示图像的宽度和高度，Compression（标签259）指示所使用的压缩方法。...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wb175208

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值