TIFF添加坐标信息

最新推荐文章于 2023-12-26 22:02:18 发布
最新推荐文章于 2023-12-26 22:02:18 发布
阅读量4.8k 收藏 15
点赞数
分类专栏： GIS相关 文章标签： tiff 图片 添加坐标
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wb175208/article/details/70038218
版权

  处理tiff图片过程中，需要给TIFF图片加上相应的坐标信息，来表示当前图片的坐标范围。下面就给出如何在一张空白的TIFF图片中添加坐标信息。
1.头文件

#pragma once
#include"tiflib.h"
#include<string>
#include <vector>
#include <algorithm>  
using namespace std;

#define TIFF_HEADER_SIZE 8    //文件头字节数
#define DE_START 10           //tiff TAG开始的位置
#define ONE_DE_SIZE 12        //每个TAG的大小
#define IDF_END_FLAG_SIZE 4   //IFD最后结尾的4个空字节
typedef struct
{
    int i_tag;
    const char* text;
}TagText;

typedef struct
{
    TIFF_UINT16_T type;
    char* type_name;
    TIFF_UINT16_T type_size;
}DataType;

typedef struct
{
    TIFF_UINT16_T tag;
    TIFF_UINT16_T type;
    TIFF_UINT32_T count;
    TIFF_UINT32_T offset;
}DirectoryEntry;

typedef struct
{
    DirectoryEntry de;
    int data_source; //0 - offset本身值 1 - offset对应的源文件偏移量 2 - 来自内存
    TIFF_UINT8_T* mem_data; //当 data_soure = 2 时 ，指向内存
}deInfo;

class tiffTrans
{
public:
    tiffTrans();
    tiffTrans( const char* tiff_path );
    ~tiffTrans();

public:
    int open( const char* tiff_path );
    void coord_box( geoRECT geo_rect );
    int save_to_trans( const char* new_path = NULL );
protected:
    int arrangement();//0 - tile  1 - line
    bool analysis( char* ret_error );  //分析tiff是否可以进行转换 true - 可以 false - 不可以  
private:
    string new_tiff_name();
    void write_file_header();

    TIFF_UINT64_T double_to_long( double d_ );
    void cs_pixel_scale( double cx , double cy );
    void cs_tie_point( double x , double y );
    void cs_coord( deInfo* coord_list );

    int get_src_tag_list();
    const char* tag_text( int i_tag );
    deInfo* cts_strip_offsets();  
    deInfo* cts_rows_per_strip();
    deInfo* cts_strip_byte_counts();

    deInfo* cts_line_tag();

    deInfo* delete_coord_tag();

    int cts_new_tag_list();

    void print_tag_info_list();
    void write_tag_list();
    void modify_strip_offset();
    void modify_line_strip();
    void modify_tile_strip();

    void sort_byte_order( TIFF_UINT8_T* buf , TIFF_UINT16_T data_type , TIFF_UINT16_T data_count );
    TIFF_UINT64_T file_disk_data( DirectoryEntry de , TIFF_UINT64_T buffer_size );

    void write_img_data();
    void write_img_data2();
    void write_line_img();
    void write_tile_img();

    void write_data( TIFF_UINT32_T data_start , TIFF_UINT32_T data_size );

private:
    FILE* _tile_tiff;
    FILE* _line_tiff;

    TiffFile* _tiff_src;
    string _src_name;
    TIFF_UINT64_T _current_file_point; //写入当前文件操作的指针

    deInfo* de_list;
    TIFF_UINT16_T _de_num;             //标签的数量
    int _coord_tag_num; //包含坐标信息的TAG的数量


    TIFF_UINT32_T _strip_offset_pos;   //TAG StripOffset or TileOffset 的文件偏移位置
    TIFF_UINT32_T _count_one_offset_pos;

    TIFF_UINT64_T pixel_scale[3];//像元比例
    TIFF_UINT64_T tie_point[6];//控制点坐标对

    geoRECT _geo_rect;
};

2.cpp文件

#include "tifftrans.h"

TagText tag_text_list[] =
{
    { 254 , "NewSubfileType" },
    { 256 , "ImageWidth" },
    { 257 , "ImageLength" },
    { 258 , "BitsPerSample" },
    { 259 , "Compression" },
    { 262 , "PhotometricInterpretation" },
    { 273 , "StripOffsets" },
    { 274 , "相对于图像的行和列的方向" },
    { 277 , "SamplesPerPixel" },
    { 278 , "RowsPerStrip" },
    { 279 , "StripByteCounts" },
    { 282 , "XResolution" },
    { 283 , "YResolution" },
    { 284 , "PlanarConfiguration" },
    { 296 , "ResolutionUnit" },
    { 305 , "Software" },
    { 306 , "DateTime" },
    { 322 , "TileWidth" },
    { 323 , "TileLength" },
    { 324 , "TileOffsets" },
    { 325 , "TileByteCounts" },
    { 339 , "SampleFormat" },
    { 33550 , "ModelPixelScaleTag" },
    { 33922 , "ModelTiepointTag" },
    { 34264 , "ModelTransformationTag" },
    { 34735 , "GeoKeyDirectoryTag" },
    { 34736 , "GeoDoubleParamsTag" },
    { 34737 , "GeoAsciiParamsTag" },
    { -1 , "" }
};

DataType data_type_list[] =
{
    { 0  , "NULL"     , 0 },//NULL
    { 1  , "BYTE"     , 1 },//BYTE 8-bit unsigned integer
    { 2  , "ASCII"    , 1 },//ASCII 8-bit byte that contains a 7-bit ASCII code; the last byte must be NUL (binary zero)
    { 3  , "SHORT"    , 2 },//SHORT 16-bit (2-byte) unsigned integer
    { 4  , "LONG"     , 4 },//LONG 32-bit (4-byte) unsigned integer
    { 5  , "RATIONAL" , 8 },//RATIONAL Two LONGs: the first represents the numerator
    { 6  , "SBYTE"    , 1 },//SBYTE An 8-bit signed (twos-complement) integer.
    { 7  , "UNDEFINED", 1 },//UNDEFINED An 8-bit byte that may contain anything, depending on the definition of the field.
    { 8  , "SSHORT"   , 2 },//SSHORT A 16-bit (2-byte) signed (twos-complement) integer
    { 9  , "SLONG"    , 4 },//SLONG A 32-bit (4-byte) signed (twos-complement) integer
    { 10 , "SRATIONAL", 8 },//SRATIONAL Two SLONG’s: the first represents the numerator of afraction, the second the denominator
    { 11 , "FLOAT"    , 4 },//FLOAT Single precision (4-byte) IEEE format
    { 12 , "DOUBLE"   , 8 } //DOUBLE Double precision (8-byte) IEEE format.

};

tiffTrans::tiffTrans()
{
    _tiff_src = new TiffFile;
    memset( _tiff_src , 0 , sizeof(TiffFile) );
    _coord_tag_num = 0 ;
}

tiffTrans::tiffTrans( const char* tiff_path )
{
    _src_name = tiff_path;
    _tiff_src = new TiffFile;
    memset( _tiff_src , 0 , sizeof(TiffFile) );
    _coord_tag_num = 0 ;
}

tiffTrans::~tiffTrans()
{
    if ( _tiff_src != NULL )
    {
        delete _tiff_src;
        _tiff_src = NULL;
    }
}

int tiffTrans::open( const char* tiff_path )
{
    _src_name = tiff_path;
    int ret = tif_open( tiff_path , _tiff_src );
    _tile_tiff = _tiff_src->pfile;

    return  ret;
}

void tiffTrans::coord_box( geoRECT geo_rect )
{
    _geo_rect = geo_rect;

    double scaleX = ( _geo_rect.right - _geo_rect.left ) / _tiff_src->tif_width;
    double scaleY = ( _geo_rect.top - _geo_rect.botton  ) / _tiff_src->tif_height;

    cs_pixel_scale( scaleX , scaleY );
    cs_tie_point( _geo_rect.left , _geo_rect.top );
}

int tiffTrans::arrangement()
{
    if( _tiff_src->tile.is_tile == true )
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

const char* tiffTrans::tag_text( int i_tag )
{
    int i = 0 ;
    while ( tag_text_list[i].i_tag != -1 )
    {
        if ( tag_text_list[i].i_tag == i_tag )
        {
            return tag_text_list[i].text;
        }
        i++;
    }

    return "";
}

void tiffTrans::write_file_header( )
{
    //字节序   
    fwrite( "II" , 2 , 1 , _line_tiff );

    //版本号
    TIFF_UINT16_T ver = 0x002a;
    fwrite( &ver , 2 , 1 , _line_tiff );

    //Tag偏移量
    TIFF_UINT32_T offset = 0x00000008;
    fwrite( &offset , 4 , 1 , _line_tiff );
}

bool tiffTrans::analysis( char* ret_error )
{
    bool b = true;
    if ( _tiff_src->bit_per_samples == 1 )
    {
        strcpy( ret_error , "错误：这是一张1位图片" );
        b = false;
    }
    else if ( _tiff_src->bit_per_samples == 4 )
    {
        strcpy( ret_error , "错误：这是一张4位图片" );
        b = false;
    }
    else if ( _tiff_src->bit_per_samples == 8 )
    {
        strcpy( ret_error , "错误：这是一张8位图片" );
        b = false;
    }

    if ( _tiff_src->compression != 1 )
    {
        strcpy( ret_error , "错误：这是一张经过压缩的图片" );
        b = false;
    }

    if( _tiff_src->planar_config != 1 )
    {
        strcpy( ret_error , "错误：Planar Config 为 Sperate ，暂时无法处理" );
        b = false;
    }

    if ( _tiff_src->tile.is_tile == false )
    {
        strcpy( ret_error , "错误：TIFF按线性方式排列数据" );
        b = false;
    }
    return b;
}

string tiffTrans::new_tiff_name()
{
    int pos = _src_name.rfind( '\\' );
    string tiff_name = _src_name.substr( pos + 1 );
    string dir = _src_name.substr( 0 , pos + 1 );
    string temp_name = "line_";
    temp_name += tiff_name ;
    return ( dir + temp_name ) ;
}

int tiffTrans::get_src_tag_list()
{
    TIFF_UINT32_T ifd_offset;      //第一个IFD的偏移量
    fseek( _tile_tiff , 0 , SEEK_SET );
    fseek( _tile_tiff ,4 ,SEEK_SET );
    ifd_offset = get4( _tile_tiff , _tiff_src->tiff_byte_order ) ;

    //定位到IFD的位置
    fseek( _tile_tiff , ifd_offset , SEEK_SET );
    //得到IFD的数量
    _de_num = get2( _tile_tiff , _tiff_src->tiff_byte_order );

    de_list = new deInfo[ _de_num ];
    memset( de_list , 0 , _de_num * sizeof( deInfo ) );

    //循环得到DE
    for ( TIFF_UINT16_T i = 0x0000 ; i < _de_num ; i++ )
    {
        fseek( _tile_tiff , ifd_offset + ONE_DE_SIZE * i + 2 , SEEK_SET );//文件指针复原指向

        de_list[i].de.tag = get2( _tile_tiff , _tiff_src->tiff_byte_order );
        de_list[i].de.type = get2( _tile_tiff , _tiff_src->tiff_byte_order );
        de_list[i].de.count = get4( _tile_tiff , _tiff_src->tiff_byte_order );

        //如果是大端字节序并且是short类型，则只会读取四个字节中的前两个字节
        if ( de_list[i].de.type == 3 && _tiff_src->tiff_byte_order == 0x4d4d/*Motor*/ && de_list[i].de.count == 1 )
        {
            de_list[i].de.offset = (TIFF_UINT32_T)get2( _tile_tiff , _tiff_src->tiff_byte_order );
        }
        else
        {
            de_list[i].de.offset = get4( _tile_tiff , _tiff_src->tiff_byte_order );
        }

        //如果是 SHORT 或者 LONG 并且数量为1，则直接存储在Offset中，并不存储地址
        if( ( de_list[i].de.type == 3 || de_list[i].de.type == 4 ) && de_list[i].de.count == 1 )
        {
            de_list[i].data_source = 0 ;
        }
        else
        {
            de_list[i].data_source = 1 ;
        }

        if ( de_list[i].de.tag == 33550 
            || de_list[i].de.tag == 33922
            || de_list[i].de.tag == 34735
            || de_list[i].de.tag == 34736
            || de_list[i].de.tag == 34737)//关于坐标的TAG
        {
            _coord_tag_num ++ ;
        }

    }

    print_tag_info_list();
    return _de_num ;
}

deInfo* tiffTrans::cts_strip_offsets()
{
    deInfo* temp_de = new deInfo;
    temp_de->de.tag = 273;
    temp_de->de.type = 4;//long
    temp_de->de.count = _tiff_src->tif_height;
    temp_de->de.offset = 0;
    temp_de->data_source = 2;
    TIFF_UINT32_T* mem = new TIFF_UINT32_T[_tiff_src->tif_height];
    memset( mem , 0 , sizeof(TIFF_UINT32_T)*_tiff_src->tif_height );
    temp_de->mem_data = (TIFF_UINT8_T*)mem;
    return temp_de;
}

deInfo* tiffTrans::cts_rows_per_strip()
{
    deInfo* temp_de = new deInfo;
    temp_de->de.tag = 278;
    temp_de->de.type = 3;//short
    temp_de->de.count = 1;
    temp_de->de.offset = 1;
    temp_de->data_source = 0;
    temp_de->mem_data = NULL;
    return temp_de;
}

deInfo* tiffTrans::cts_strip_byte_counts()
{
    deInfo* temp_de = new deInfo;
    temp_de->de.tag = 279;
    temp_de->de.type = 4;//short
    temp_de->de.count = _tiff_src->tif_height;
    temp_de->de.offset = 0;
    temp_de->data_source = 2;
    TIFF_UINT32_T* mem = new TIFF_UINT32_T[_tiff_src->tif_height];
    memset( mem , 0 , sizeof(TIFF_UINT32_T)*_tiff_src->tif_height );
    for ( int i = 0 ; i < _tiff_src->tif_height ; i++ )
    {
        mem[i] = _tiff_src->tif_width * _tiff_src->samples_per_pixel;
    }
    temp_de->mem_data = (TIFF_UINT8_T*)mem;
    return temp_de;
}

deInfo* tiffTrans::cts_line_tag()
{
    deInfo* temp_line_tag_list = new deInfo[3];
    memset( temp_line_tag_list , 0 , sizeof(deInfo) * 3 );
    deInfo* temp = cts_strip_offsets();
    memcpy( temp_line_tag_list , temp , sizeof(deInfo) ) ;
    delete temp;
    temp = cts_rows_per_strip();
    memcpy( temp_line_tag_list + 1 , temp , sizeof(deInfo));
    delete temp;
    temp = cts_strip_byte_counts();
    memcpy( temp_line_tag_list + 2 , temp , sizeof(deInfo));
    delete temp;
    temp = NULL;
    return temp_line_tag_list;
}

deInfo* tiffTrans::delete_coord_tag()
{
    deInfo* temp_de_list = new deInfo[ _de_num - _coord_tag_num ];//删除坐标TAG
    memset( temp_de_list , 0 , sizeof(deInfo)*( _de_num - _coord_tag_num ) );

    int j = 0;
    for ( int i = 0 ; i < _de_num ; i ++ )
    {
        if ( ( de_list[i].de.tag != 33550 )&& 
            ( de_list[i].de.tag != 33922 )&& 
            ( de_list[i].de.tag != 34735 )&& 
            ( de_list[i].de.tag != 34736 )&&
            ( de_list[i].de.tag != 34737 )
            )
        {
            memcpy ( temp_de_list + j , de_list + i , sizeof(deInfo) );
            j++;
        }
    }

    delete[] de_list;
    de_list = NULL;
    de_list = temp_de_list;
    _de_num -= _coord_tag_num ;
    return de_list;
}

int tiffTrans::cts_new_tag_list( )
{
    delete_coord_tag( );//删除所有的关于坐标的TAG
    deInfo* temp_line = new deInfo[2];
    memset( temp_line , 0 ,  2 * sizeof( deInfo ) );
    cs_coord( temp_line );

    deInfo* temp_de_list = new deInfo[ _de_num + 2 ];//tile 4个标签 line 只需要3个标签
    memset( temp_de_list , 0 , sizeof(deInfo)*( _de_num + 2 ) );

    int j = 0 , k = 0 ;
    for ( int i = 0 ; i < _de_num ; i++ )
    {
        if ( k < 2 )//只有二个标签
        {
            if ( de_list[i].de.tag < temp_line[k].de.tag )
            {
                memcpy( temp_de_list + j , de_list + i , sizeof( deInfo ) );
                j++;
            }
            else
            {
                memcpy( temp_de_list + j , temp_line + k , sizeof( deInfo ) );
                j++;
                k++;
                i--;
            }
        }
        else
        {
            memcpy( temp_de_list + j , de_list + i , sizeof( deInfo ) );
            j++;
        }
    }

    if ( k < 2 )
    {
        int temp = k;
        for ( int i = temp ; i < 2 ; i++ )
        {
            temp_de_list[ j ] = temp_line[ k ];
            j ++;
            k ++;
        }
    }

    delete[] de_list;
    de_list = NULL;
    de_list = temp_de_list;
    _de_num += 2;

    print_tag_info_list();
    return 0;
}

void tiffTrans::print_tag_info_list()
{
    printf( "\n" );
    for ( int i = 0 ; i < _de_num ; i++ )
    {
        char outStr[1024];
        memset( outStr , 0 , 1024 * sizeof( char ) );
        sprintf( outStr , "0x%04x[ %5d %-26s ] , 0x%02x , 0x%04x( %5d ) , 0x%08x , %d \n" 
            , de_list[i].de.tag 
            , de_list[i].de.tag
            , tag_text( de_list[i].de.tag )
            , de_list[i].de.type 
            , de_list[i].de.count
            , de_list[i].de.count
            , de_list[i].de.offset 
            , de_list[i].data_source ) ;
        printf( outStr );
    }
}

void tiffTrans::write_tag_list()
{
    _strip_offset_pos = 0;
    _count_one_offset_pos = 0;
    for ( int i = 0 ; i < _de_num ; i++ )
    {
        fseek( _line_tiff , DE_START + ONE_DE_SIZE * i , SEEK_SET );
        fwrite( &( de_list[i].de.tag ) , 2 , 1 , _line_tiff );   //TAG 2字节
        fwrite( &( de_list[i].de.type ) , 2 , 1 , _line_tiff );  //数据类型 2字节
        fwrite( &( de_list[i].de.count ) , 4 , 1 , _line_tiff ); //count 4字节    

        if( ( de_list[i].de.tag == 273 || de_list[i].de.tag == 324 ) && de_list[i].de.count > 1 )//Strip offset or TileOffset
        {
            fseek( _line_tiff , 0 , SEEK_END );
            _strip_offset_pos = ftell( _line_tiff );
        }
        else if(  de_list[i].de.tag == 273 && de_list[i].de.count == 1 )//Strip offset or TileOffset值保存在OFFSET中
        {
            fseek( _line_tiff , DE_START + ONE_DE_SIZE * i + 8 , SEEK_SET );
            _count_one_offset_pos = ftell( _line_tiff );
            fseek( _line_tiff , 0 , SEEK_END );
        }

        //写入offset
        if( de_list[i].data_source == 0 )//直接写入值
        {
            fwrite( &( de_list[i].de.offset ) , 4 , 1 , _line_tiff );
        }
        else if ( de_list[i].data_source == 1 )//文件对应的偏移量
        {
            fseek( _line_tiff , 0 , SEEK_END );

            TIFF_UINT32_T pos = ftell( _line_tiff );

            TIFF_UINT64_T buffer_size = data_type_list[de_list[i].de.type].type_size * de_list[i].de.count;
            file_disk_data( de_list[i].de , buffer_size );

            //修改TAG对应的数据存放的地址
            fseek( _line_tiff , DE_START + ONE_DE_SIZE * i + 8 , SEEK_SET );
            fwrite( &pos , 1 , 4 , _line_tiff );
        }
        else if ( de_list[i].data_source == 2 )//内存
        {
            fseek( _line_tiff , 0 , SEEK_END );
            TIFF_UINT32_T pos = ftell( _line_tiff );
            fwrite ( de_list[i].mem_data , 1 ,  data_type_list[de_list[i].de.type].type_size * de_list[i].de.count  , _line_tiff );

            //修改TAG对应的数据存放的地址
            fseek( _line_tiff , DE_START + ONE_DE_SIZE * i + 8 , SEEK_SET );
            fwrite( &pos , 1 , 4 , _line_tiff );

            if ( !( ( de_list[i].de.tag == 33550 ) || ( de_list[i].de.tag == 33922 ) ) )
            {
                delete[] de_list[i].mem_data;
            }

        }
    }
}

TIFF_UINT64_T tiffTrans::file_disk_data( DirectoryEntry de , TIFF_UINT64_T buffer_size )
{
    fseek( _tile_tiff , de.offset , SEEK_SET );

    TIFF_UINT8_T* buf = new TIFF_UINT8_T[1024];
    memset( buf , 0 , 1024 );

    TIFF_UINT64_T fs = 0;
    TIFF_UINT16_T read_size = 0;
    if ( buffer_size <= 1024 )//若小于1024字节，则读取之后直接写入即可
    {
        read_size = fread( buf , 1 , buffer_size , _tile_tiff );

        if( _tiff_src->tiff_byte_order == TIFF_BIGENDIAN && data_type_list[de.type].type_size != 1 )
        {
            sort_byte_order( buf , de.type , de.count );
        }

        fs += fwrite ( buf , 1 , read_size , _line_tiff );
    }
    else//若大于1024字节，则分批写入1024字节，最后写入不足1024的字节
    {
        TIFF_UINT16_T tile_num = ( int )(buffer_size / 1024) ;
        TIFF_UINT16_T last_num = buffer_size % 1024;
        for ( int i = 0 ; i < tile_num ; i++ )
        {
            read_size = fread( buf , 1 , 1024 , _tile_tiff );//注意参数的顺序
            if( _tiff_src->tiff_byte_order == TIFF_BIGENDIAN && data_type_list[de.type].type_size != 1 )
            {
                sort_byte_order( buf , de.type , de.count );
            }
            fs += fwrite ( buf , 1 , read_size , _line_tiff );
        }

        read_size = fread( buf , 1 , last_num , _tile_tiff );
        if( _tiff_src->tiff_byte_order == TIFF_BIGENDIAN && data_type_list[de.type].type_size != 1 )
        {
            sort_byte_order( buf , de.type , de.count );
        }
        fs += fwrite ( buf , 1 , last_num , _line_tiff );
    }
    delete[] buf;
    buf = NULL;
    return fs;
}

void tiffTrans::sort_byte_order( TIFF_UINT8_T* buf , TIFF_UINT16_T data_type , TIFF_UINT16_T data_count )
{
    TIFF_UINT8_T* p = buf;

    for ( TIFF_UINT16_T i = 0 ; i < data_count ; i++ )
    {
        if ( data_type == 3 || data_type == 8 )//SHORT
        {
            TIFF_UINT16_T ret = sget2( p , TIFF_BIGENDIAN );
            memcpy( p , &ret , 2 );
            p += 2;
        }
        else if ( data_type == 4 ||  data_type == 9 ||  data_type == 11 )//LONG
        {
            TIFF_UINT32_T ret = sget4( p , TIFF_BIGENDIAN );
            memcpy( p , &ret , 4 );
            p += 4;
        }
        if ( data_type == 5 || data_type == 10 )
        {
            TIFF_UINT32_T ret = sget4( p , TIFF_BIGENDIAN );
            memcpy( p , &ret , 4 );
            p += 4;

            ret = sget4( p , TIFF_BIGENDIAN );
            memcpy( p , &ret , 4 );
            p += 4;
        }
        else if ( data_type == 12 )//DOUBLE
        {
            TIFF_UINT64_T ret = sget8( p , TIFF_BIGENDIAN );
            memcpy( p , &ret , 8 );
            p += 8;
        }
    }
}

void tiffTrans::modify_line_strip()
{
    fseek( _line_tiff , 0 , SEEK_END );
    TIFF_UINT32_T current_size = ftell( _line_tiff );
    if( _count_one_offset_pos > 0 )//Strip offset or TileOffset值保存在OFFSET中
    {
        fseek( _line_tiff , _count_one_offset_pos , SEEK_SET );
        fwrite( &current_size , 1 , 4 , _line_tiff );
    }
    else if ( _strip_offset_pos > 0 )
    {
        fseek( _line_tiff , _strip_offset_pos , SEEK_SET );
        for ( int i = 0 ; i < _tiff_src->bcount_strip_offset ; i++ )
        {
            TIFF_UINT32_T offset_pos = current_size + i * _tiff_src->strip_byte_counts[i];
            fwrite( &offset_pos , 1 , 4 , _line_tiff );
        }
    }
}

void tiffTrans::modify_tile_strip()
{
    fseek( _line_tiff , 0 , SEEK_END );
    TIFF_UINT32_T current_size = ftell( _line_tiff );
    fseek( _line_tiff , _strip_offset_pos , SEEK_SET );
    TIFF_UINT32_T tile_bytes = _tiff_src->tile.tile_height * _tiff_src->tile.tile_width * _tiff_src->samples_per_pixel ;
    TIFF_UINT32_T tile_satrt = current_size ;
    for ( int i = 0 ; i < _tiff_src->tile.tile_offset_count ; i++ )
    {
        TIFF_UINT32_T tile_satrt = current_size ;
        tile_satrt += i * tile_bytes ;
        fwrite( &tile_satrt , 1 , 4 , _line_tiff );
    }
}

void tiffTrans::modify_strip_offset()
{
    if( _tiff_src->tile.is_tile )
    {
        modify_tile_strip( );
    }
    else
    {
        modify_line_strip( );
    }
}

void tiffTrans::write_img_data()
{
    int table_w = (int)( _tiff_src->tif_width / _tiff_src->tile.tile_width );
    if ( _tiff_src->tif_width % _tiff_src->tile.tile_width > 0 )
    {
        table_w ++ ;
    }
    int table_h = (int)( _tiff_src->tif_height/ _tiff_src->tile.tile_height)+1;

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

    fseek( _line_tiff , 0 , SEEK_END );
    TIFF_UINT64_T cur_size = ftell( _line_tiff );

    for( int i_height = 0 ; i_height < _tiff_src->tif_height ; i_height++ )//按行添加
    {
        system("cls");
        printf( "%s\n Tile -> Line %d / %d \n" ,_src_name.c_str(), i_height+1 , _tiff_src->tif_height  );
        fseek( _line_tiff , cur_size + i_height * ( _tiff_src->tif_width * _tiff_src->samples_per_pixel ) , SEEK_SET );
        int temp_table_h = i_height / _tiff_src->tile.tile_height;//确定tile的行高
        int tile_h = i_height % _tiff_src->tile.tile_height;
        for ( int i_w_table = 0 ; i_w_table < table_w ; i_w_table ++ )//按tile的列填充
        {
            TIFF_UINT32_T table_pos = temp_table_h * table_w + i_w_table;

            TIFF_UINT32_T table_start = _tiff_src->tile.tile_offset_list[ table_pos ] + ( _tiff_src->tile.tile_width * _tiff_src->samples_per_pixel) *tile_h ;
            fseek( _tile_tiff , table_start , SEEK_SET );
            TIFF_UINT8_T* buf = new TIFF_UINT8_T[ _tiff_src->tile.tile_width * _tiff_src->samples_per_pixel ];
            fread( buf , 1 , _tiff_src->tile.tile_width * _tiff_src->samples_per_pixel , _tile_tiff );
            fwrite( buf , 1 , _tiff_src->tile.tile_width * _tiff_src->samples_per_pixel , _line_tiff );

            delete[] buf;
            buf = NULL;
        }
    }
}

void tiffTrans::write_img_data2()
{
    if ( _tiff_src->tile.is_tile )
    {
        write_tile_img( );
    }
    else
    {
        write_line_img( );
    }
}

void tiffTrans::write_line_img( )
{
    fseek( _line_tiff , 0 , SEEK_END );
    for ( int i = 0 ; i < _tiff_src->bcount_strip_offset ; i ++ )
    {
        write_data( _tiff_src->strip_line[i] , _tiff_src->strip_byte_counts[i] );
    }

}

void tiffTrans::write_tile_img( )
{
    fseek( _line_tiff , 0 , SEEK_END );

    for ( int i = 0 ; i < _tiff_src->tile.tile_offset_count ; i ++ )
    {
        write_data( _tiff_src->tile.tile_offset_list[i] , _tiff_src->tile.tile_byte_num_list[i] );
    }
}

void tiffTrans::write_data( TIFF_UINT32_T data_start , TIFF_UINT32_T buffer_size )
{
    fseek( _tile_tiff , data_start , SEEK_SET );

    TIFF_UINT8_T* buf = new TIFF_UINT8_T[1024];
    memset( buf , 0 , 1024 );

    TIFF_UINT16_T read_size = 0;
    if ( buffer_size <= 1024 )//若小于1024字节，则读取之后直接写入即可
    {
        read_size = fread( buf , 1 , buffer_size , _tile_tiff );
        fwrite ( buf , 1 , read_size , _line_tiff );
    }
    else//若大于1024字节，则分批写入1024字节，最后写入不足1024的字节
    {
        TIFF_UINT16_T tile_num = ( int )(buffer_size / 1024) ;
        TIFF_UINT16_T last_num = buffer_size % 1024;
        for ( int i = 0 ; i < tile_num ; i++ )
        {
            read_size = fread( buf , 1 , 1024 , _tile_tiff );//注意参数的顺序

            fwrite ( buf , 1 , read_size , _line_tiff );
        }
        read_size = fread( buf , 1 , last_num , _tile_tiff );
        fwrite ( buf , 1 , last_num , _line_tiff );
    }
    delete[] buf;
    buf = NULL;
}

int tiffTrans::save_to_trans( const char* new_path )
{
    string temp_path;
    if (  new_path == NULL )
    {
        temp_path = new_tiff_name() ;
    }
    else
    {
        temp_path = new_path;
    }

    _line_tiff = fopen( temp_path.c_str() , "wb" );
    if ( _line_tiff == NULL )
    {
        return -1 ;
    }

    //1.写入TIFF的文件头
    write_file_header( );

    //读取原来的TIFF中的TAG标签
    get_src_tag_list( );

    //生成新的TAG列表
    cts_new_tag_list( );
    //2.写入tag的数量
    fwrite( &( _de_num ) , 1 , 2 , _line_tiff );
    //3.写入空的DE占位空间
    TIFF_UINT8_T* place_holder = new TIFF_UINT8_T[ _de_num * ONE_DE_SIZE + IDF_END_FLAG_SIZE ];
    memset( place_holder , 0 , _de_num * ONE_DE_SIZE + IDF_END_FLAG_SIZE );
    fwrite( place_holder , 1 , _de_num * ONE_DE_SIZE + IDF_END_FLAG_SIZE , _line_tiff );

    TIFF_UINT64_T write_file_size = ftell( _line_tiff );
    //4.写入具体的TAG内容和对应的偏移量
    write_tag_list();


    //5.修改图像数据的偏移量
    modify_strip_offset();

    //6.写入图像数据
    write_img_data2();

    fclose( _line_tiff );

    delete[] place_holder;
    place_holder = NULL;
    return 0;
}

TIFF_UINT64_T tiffTrans::double_to_long( double d_ )
{
    union { TIFF_UINT64_T i; double f; } u;
    u.f = d_ ;
    return u.i ;
}

void tiffTrans::cs_pixel_scale( double cx , double cy )
{
    pixel_scale[0] = double_to_long ( cx );
    pixel_scale[1] = double_to_long ( cy );
    pixel_scale[2] = 0 ;
}

void tiffTrans::cs_tie_point( double x , double y )
{
    tie_point[0] = 0;
    tie_point[1] = 0;
    tie_point[2] = 0;

    tie_point[3] = double_to_long( x ) ;
    tie_point[4] = double_to_long( y ) ;
    tie_point[5] = 0;
}

void tiffTrans::cs_coord( deInfo* coord_list )
{
    coord_list[0].de.tag = 33550;//GeoTagPixelScale
    coord_list[0].de.type = 12;//double
    coord_list[0].de.count = 3 ;
    coord_list[0].data_source = 2;//内存数据
    coord_list[0].mem_data = ( TIFF_UINT8_T* )pixel_scale;

    coord_list[1].de.tag = 33922;//GeoTagTiePoint
    coord_list[1].de.type = 12;//double
    coord_list[1].de.count = 6 ;
    coord_list[1].data_source = 2;//内存数据
    coord_list[1].mem_data = ( TIFF_UINT8_T* )tie_point;

}

3.使用方法：

#include <stdio.h>
#include <string>
using namespace std;

#include "tifftrans.h"

string save_name( string str_path , string str_save_dir );

int main( int argc, char* argv[] )
{
    if ( argc < 7 )
    {
        printf( "参数输入的不正确！\n[D:\\xxx.tif] [上] [下] [左] [右] 四个方向上的坐标 [D:\\xxx] " );
        return -1;
    }

    string str_path( argv[1] );
    string str_top ( argv[2] );
    string str_botton ( argv[3] );
    string str_left ( argv[4] );
    string str_right ( argv[5] );
    string str_save_dir ( argv[6] );

    tiffTrans tiff_trans;
    tiff_trans.open( str_path.c_str() );
    geoRECT geo_box;
    geo_box.top = atof( str_top.c_str() );
    geo_box.botton = atof( str_botton.c_str() );
    geo_box.left = atof( str_left.c_str() );
    geo_box.right = atof( str_right.c_str() );
    tiff_trans.coord_box( geo_box );
    tiff_trans.save_to_trans( /*"D:\\123.tiff"*/ save_name( str_path , str_save_dir ).c_str() );

    return 0;
}

string save_name( string str_path , string str_save_dir )
{
    int pos = str_path.rfind('\\');
    string tif_name = str_path.substr( pos + 1 );
    string temp = "\\coord_";
    temp += tif_name ;
    return str_save_dir + temp;
}
wb175208
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
cad插入带坐标tif文件（tif函数）
08-22
CAD插影像插件。。
Tiff、jpg图片怎么样添加地理坐标信息
热门推荐
树木_xzw的博客
10-09 2万+
Tiff、jpg图片怎么样添加地理坐标信息 一般，外业调查只有地图资料，如专题图、或者地形图，如何把这些地图资料的扫描地图带上坐标信息，从而内业实现信息化处理？以上问题，可以解决，但根据不同情况有不同的处理方法。     第一种，上面有经纬度外框，图片是矩形，但是没有地理信息。 通过图框的两个角的坐标确定范围，分别是左上（140°E，30°N）；右下（150°W，30°N） 解决方
TIFF文件处理工具
04-27
TIFF文件的处理，包括文件的读写修改，坐标的添加和修改
cad插入带坐标tif文件（tif命令）.zip
10-12
cad插入带坐标tif文件（tif命令）.zip，解决cad插入带坐标tif坐标偏移的问题。
c++读写geotiff格式添加坐标信息和投影信息
08-04
用 libgeotiff 库写geotiff格式数据，包括 地理坐标系和投影信息。
利用ArcGIS软件赋予tif影像空间参考坐标系
晓晨的博客
04-23 6171
利用ArcGIS软件中的Georeferencing工具，选择三个及以上的关联点，即可求解空间中的任意平移、旋转变换。
获取tif文件四角经纬、页面渲染tif文件
weixin_46272394的博客
03-27 1656
本文使用读取tif文件获取经纬度信息， GeoTools是可以操作和显示地图的开源Java代码库GeoTools，它提供了一系列符合规范的操作地理空间数据的方法，例如可以用它来实现一个（GIS）。对比它无需安装本地库和配置环境变量，使用便捷。gdal 主要使用 C/C++ 编写，但它也支持许多其他编程语言，如 Python、Java 和 Ruby。GeoTools 是用 Java 编写的，因此它更适合 Java 开发者。
【TIFF GPS】TIFF图像添加EXIF的GPS信息标记
最新发布
llloverxz的博客
12-26 974
C# 通过LibTIFF开源库为TIFF图像插入Exif的GPS标记信息
python读取tif图像+经纬度
alex1801
02-24 5248
则，左上角的地理坐标为：(GT(0) , GT(3) )，如果图像不含地理坐标信息，默认返回值是：(0,1,0,0,0,1)；（2）用ReadAsArray(, , ,)，读出从(xoff,yoff)开始，大小为(xsize,ysize)的矩阵。GeoTIFF使用gdal进行读取，GDAL 是一个开源的操作栅格数据和矢量数据的库，可用于读写、获取坐标系、获取指定位置像元值等。（1）读取一个波段，其参数为波段的索引号，波段索引号从1开始(我打开的这幅图像只有一个波段)4：列旋转，如果图像北方朝上，该值为0；
Python gdal tif图加坐标信息
点绛唇
04-27 2718
import gdal # 读文件 YG_dataset = gdal.Open(r'D:\lppyqtdata\yuantu2\zhangzha1.tif') # 打开文件，用这个tif图的投影信息 YG_geotrans = YG_dataset.GetGeoTransform() # 仿射矩阵 print(YG_geotrans) YG_proj = YG_dataset.GetProjection() # 地图投影信息 print(YG_proj) # 读文件 YG2_dataset ..
给img、tif影像添加坐标系
07-10
用GDAL给img影像添加坐标，并转化成tif
GeotiffLandscape：UE4插件支持geotiff作为景观文件格式
02-06
GeotiffLandscape-UE4插件 将geotiff文件添加为UE4景观高度/重量地图文件类型和自定义数据资产类型。 这可用于从现有位置生成真实比例的UE4地图。 Geotiff数字高程模型（DEM）包含有关地图地理坐标的信息以及有关最大和最小海拔的信息。 利用此信息，可以使用此插件创建1：1比例的景观。 同样，也可以将geotiff土地覆盖文件导入命名的景观层。 产品特点 景观高度图文件格式Geotiff 景观权重图文件格式Geotiff 横向权重图文件格式S2GLC S2GLC层的分层景观材料示例 纹理的红色和绿色通道中具有16bit高度的GeotiffHeightmap资
python2.7栅格数据批量转换投影
09-15
python2.7栅格数据批量转换投影:ProjectRaster_management (in_raster, out_raster, out_coor_system, {resampling_type}, {cell_size}, {geographic_transform}, {Registration_Point}, {in_coor_system}) in_raster 输入栅格数据集。Mosaic Layer; Raster Layer out_raster 要创建的输出栅格数据集。以文件格式存储栅格数据集时，需要指定文件扩展名，具体如下：.bil - Esri BIL, .bip - Esri BIP, .bmp - BMP, .bsq - Esri BSQ, .dat - ENVI DAT,.gif - GIF,.img - ERDAS IMAGINE,.jpg - JPEG,.jp2 - JPEG 2000,.png - PNG,.tif - TIFF,无扩展名 - Esri Grid,以地理数据库形式存储栅格数据集时，不应向栅格数据集的名称添加文件扩展名。 将栅格数据集存储到 JPEG 文件、JPEG 2000 文件、TIFF 文件或地理数据库时，可以指定压缩类型和压缩质量。 Raster Dataset out_coor_system 输入栅格待投影到的目标坐标系。默认值将基于“输出坐标系”环境设置进行设定。该参数的有效值是扩展名为 .prj 的文件。现有要素类、要素数据集、栅格目录（基本上包含了与坐标系相关的所有内容）。坐标系的字符串表示。要生成此类较长的字符串，可向模型构建器添加一个坐标系变量，并根据需要设置该变量的值，然后将模型导出到 Python 脚本。 Coordinate System resampling_type (可选) 要使用的重采样算法。默认设置为 NEAREST。 NEAREST —最邻近分配法 BILINEAR —双线性插值法 CUBIC —三次卷积插值法 MAJORITY —众数重采样法 NEAREST 和 MAJORITY 选项用于分类数据，如土地利用分类。NEAREST 选项是默认设置，因为它是最快的插值法，同时也因为它不会更改像元值。请勿对连续数据（如高程表面）使用 NEAREST 或 MAJORITY。BILINEAR 选项和 CUBIC 选项最适用于连续数据。不推荐对分类数据使用 BILINEAR 或者 CUBIC，因为像元值可能被更改。 cell_size (可选) 新栅格数据集的像元大小。默认像元大小为所选栅格数据集的像元大小。 Cell Size XY geographic_transform (可选) 在两个地理坐标系或基准面之间实现变换的方法。当输入和输出坐标系的基准面相同时，地理（坐标）变换为可选参数。如果输入和输出基准面不同，则必须指定地理（坐标）变换。 有关各个受支持的地理（基准面）变换的详细信息，请参阅位于 ArcGIS 安装目录的 \Documentation 文件夹下的 geographic_transformations.pdf 文件。 Registration_Point(可选)用于对齐像素的 x 和 y 坐标（位于输出空间中）。配准点的工作原理与捕捉栅格的概念类似。通过配准点可指定用于定位输出像元的原点，而不是仅将输出捕捉到现有栅格像元。所有输出像元与该点之间必须间隔一个像元。该点的坐标不必位于一角，也不必落入栅格数据集中。捕捉栅格环境设置参数将优先于 Registration_Point 参数。因此，如果您要设置配准点，请确保尚未设置捕捉栅格。 in_coor_system (可选) 输入栅格数据集的坐标系。Coordinate System
获取某种颜色在图片中所占的比例
wb175208的专栏
12-25 2万+
如何在一张图片中找到与自己想要的颜色值最相近的颜色，并且求出这些颜色在整张图片中所占的比例。比如对着一片绿地拍了一张照片然后想要查看一下那片绿地在整张照片中的范围，大概估算一下绿地的面积等等类似的场景。虽然比一定准确但是还是会有一定的参考价值。 核心算法代码：/* init_red, init_green, init_blue --- 需要查找到的颜色值 red, green, blue ---
ArcGIS的.prj文件生成proj4格式的字符串
wb175208的专栏
01-10 1万+
ArcGIS的prj文件是一个专门用来描述坐标系投影的文件，里面定义了坐标系的名称、长短半轴、基准面、投影参数等一些其他重要的信息。proj4是C用语言编写的专门用来处理各个坐标系之间的转换的开源库。可以实现经纬度坐标转平面坐标或者两个不同的椭球体之间的坐标系转换，运算精度高，计算准确，在很多GIS项目和软件中都有使用。   那么既然都是描述坐标系的文件，如何在他们之间进行转换呢，下面举个例子：P
RecyclerView存在大量Item时,当滚到底部时快速滑到顶部
wb175208的专栏
03-17 9520
在使用RecyclerView展示图片或者其他信息时，往往需要展示很多的Item,当滚到底部时又想回到顶部，如果一点一点的向上划去比较麻烦，而且用户体验不好。因此添加一个快速回到顶部的按钮是很有必要的，并且刚开始的时候这个按钮是隐藏的，当滑动超过超过一屏的时候才会出现，在滑动的过程中也是不会出现的。很多类似的项目都会使用到，但是如何在快速回到顶部的过程中不出现卡顿，体现的很是流畅，这点很重要。下面是
Google投影坐标和WGS84坐标系的转换
wb175208的专栏
01-09 9403
web墨卡托坐标是google投影坐标系，而google投影坐标系是建立在一个长半轴等于短半轴的椭球上面，也就是所google投影是建立在一个正圆球上面，是平面坐标系，而WGS84经纬度坐标是GPS定位是的坐标系。他们之间的坐标之间的关系如下： C++代码：typedef struct { double x; double y; }coordPairs;//web墨卡托转成WGS经
QGIS在地图上绘制经纬网
wb175208的专栏
10-19 8543
利用GIS加载经纬网的SHP数据可以显示经纬网数据，但是QGIS本身也具备显示经纬网的功能。 QGIS显示经纬网数据利用类：QgsDecorationGrid 。这个类可以构造一个SHP图层来显示出来。 但是我并没有使用QGIS库中的这个类，而是直接使用的源码，把这个类进行了改造，并且可以修改样式（颜色、字体等信息）。 先贴上修改过的类文件： #ifndef QGSDECORATIONGRID...
TIFF坐标的转换，生成新的图像
wb175208的专栏
03-14 7205
TIFF图片可以存储坐标信息，但是如何对这些坐标信息进行转换，然后生成新的图片呢？首先需要知道现在TIFF图片中的坐标系，然后要知道被转换的坐标系。现在我们只支持WGS84、西安80、北京54等中国常用的坐标系。 坐标系转换的头文件：#pragma once #include "proj_api.h"#define PROJ4_COUNT 1024 #define coord_wgs84 "+pr
tiff图片原坐标导入cad的插件
07-21
### 回答1： 要将tiff图片的原坐标导入CAD插件，首先需要找到一个支持tiff格式并具备此功能的插件。一种常见的选择是AutoCAD软件本身，它具有强大的CAD绘图功能，并支持多种图片格式的导入。 在AutoCAD中，我们可以通过以下步骤实现该功能。首先，打开AutoCAD软件并创建一个新的绘图文件。然后，选择“插入”选项卡中的“图像”命令，在弹出的对话框中选择要导入的tiff图片。 在导入图片后，AutoCAD会将其默认放置在绘图区域的左下角，并使用自身的坐标系统进行定位。为了保持tiff图片的原始坐标，我们可以将其移动到合适的位置。 首先，选择“修改”选项卡中的“移动”命令，然后选择要移动的图片对象。接下来，输入参考点的原始坐标和目标坐标，这样AutoCAD就会按照我们输入的坐标将图片移动到指定位置。 当完成上述步骤后，我们就成功将tiff图片的原坐标导入CAD插件中了。通过这种方法，我们可以在CAD软件中使用tiff图片，并按照原始坐标进行进一步绘图、编辑和处理。 ### 回答2： tiff图片原坐标导入CAD的插件，是一种类型的软件工具，旨在帮助用户将基于TIFF格式的图片以保持其原始坐标的方式导入到计算机辅助设计（CAD）软件中。 通常情况下，CAD软件并不直接支持TIFF图片的导入，因为TIFF是一种图像格式，其中包含了图像的像素信息，而不是坐标信息。因此，使用插件可以帮助用户在CAD软件中导入和处理TIFF图片，而不会丢失图像的原始坐标信息。 这些插件通常包括一系列功能，可以通过选择、缩放和旋转等操作，精确地将TIFF图片定位在CAD软件的坐标系统中。插件可能还提供一些额外的功能，例如自动校准图像、调整图像亮度和对比度等。 TIFF图片原坐标导入CAD的插件可以广泛应用于多个领域。例如，在土地测量、建筑设计和工程绘图等方面，工程师和设计师可以使用这些插件，将现场采集的地理信息系统（GIS）数据以TIFF格式导入CAD软件，以便在CAD中进行进一步的设计和分析。 总之，TIFF图片原坐标导入CAD的插件是一种有用的工具，可以帮助用户在CAD软件中有效处理TIFF图像，并确保图像的原始坐标信息得以保留，使得用户能够更准确地进行设计和分析工作。 ### 回答3： Tiff图片原坐标导入CAD插件是一种可用于将Tiff格式的图片以其原始坐标导入到CAD软件中的扩展工具。这种插件可以极大地简化CAD设计过程中的图像导入操作，提高工作效率。 使用该插件，用户可以直接选择要导入的Tiff图片并将其添加到CAD软件中。插件会自动将Tiff图片的原始坐标信息与CAD中的坐标系统进行匹配，确保图像的准确导入。这意味着无需手动调整图像位置或重新定位，因为插件能够自动将其放置在正确的位置上。 此外，该插件还具有一些额外功能，例如根据用户的需要进行图像缩放、旋转或倾斜。通过使用这些功能，用户可以根据实际情况对导入的Tiff图片进行调整，以满足具体设计要求。 总的来说，Tiff图片原坐标导入CAD的插件是一款功能强大且易于使用的工具，可以帮助用户更高效地将Tiff格式的图片导入到CAD软件中，并保持其原始坐标。它大大简化了设计过程中的图像导入操作，并提供了额外的调整功能，使用户能够更好地适应各种设计需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wb175208

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

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

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

打赏作者

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

抵扣说明：

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

余额充值