精华内容
下载资源
问答
  • 图像处理:根据像素坐标及像素尺寸大小裁剪遥感影像
    千次阅读
    2019-05-31 19:17:02

    1 需求

    对于遥感影像,在制作数据集中需要裁剪固定尺寸大小的图片,本来打算用通用一点的软件arcgis实现,但在arcgis中的裁剪功能设置裁剪位置的单位是十进制度的,这个单位也不知道怎么改变为像素单位,最后没办法,使用了下面两种方式实现!

    2 方法

    方法一

    使用PIE-Basic软件,这款软件是北京航天宏图研发的,具体操作如下:
    1·打开软件,加载原始影像数据,找到感兴趣区域,使用探针工具找到中心坐标并记录;
    在这里插入图片描述
    2·打开图像裁剪按钮,点击后弹出如下窗口,根据刚才找到的坐标中心及自己想要的尺寸大小,依次填写想要输出的像素范围,输出文件路径,点击确认即可完成
    在这里插入图片描述

    方法二

    使用python代码结合GDAL开源包完成,代码如下:

    # -*- coding: utf-8 -*-
    """
    Created on Tue Apr  2 18:00:21 2019
    
    @author: Administrator
    """
    
    import gdal
    
    in_ds = gdal.Open("D:\\Data\\test.tif")			  # 读取要切的原图
    print("open tif file succeed")
    width = in_ds.RasterXSize                         # 获取数据宽度
    height = in_ds.RasterYSize                        # 获取数据高度
    outbandsize = in_ds.RasterCount                   # 获取数据波段数
    im_geotrans = in_ds.GetGeoTransform()             # 获取仿射矩阵信息
    im_proj = in_ds.GetProjection()                   # 获取投影信息
    datatype = in_ds.GetRasterBand(1).DataType
    im_data = in_ds.ReadAsArray()                     #获取数据 
    
    # 读取原图中的每个波段
    in_band1 = in_ds.GetRasterBand(1)
    in_band2 = in_ds.GetRasterBand(2)
    in_band3 = in_ds.GetRasterBand(3)
    
    # 定义切图的起始点坐标
    # offset_x = 0  
    # offset_y = 0
    offset_x = width/2  
    offset_y = height/2
    
    # 定义切图的大小(矩形框)
    block_xsize = 1000  # 行
    block_ysize = 1000  # 列
    
    ## 从每个波段中切需要的矩形框内的数据(注意读取的矩形框不能超过原图大小)
    out_band1 = in_band1.ReadAsArray(offset_x, offset_y, block_xsize, block_ysize)
    out_band2 = in_band2.ReadAsArray(offset_x, offset_y, block_xsize, block_ysize)
    out_band3 = in_band3.ReadAsArray(offset_x, offset_y, block_xsize, block_ysize)
    
    # 获取Tif的驱动,为创建切出来的图文件做准备
    gtif_driver = gdal.GetDriverByName("GTiff")
    
    # 创建切出来的要存的文件
    out_ds = gtif_driver.Create('clip5.tif', block_xsize, block_ysize, outbandsize, datatype)
    #print("create new tif file succeed")
    
    # 获取原图的原点坐标信息
    ori_transform = in_ds.GetGeoTransform()
    if ori_transform:
            print (ori_transform)
            print("Origin = ({}, {})".format(ori_transform[0], ori_transform[3]))
            print("Pixel Size = ({}, {})".format(ori_transform[1], ori_transform[5]))
    
    # 读取原图仿射变换参数值
    top_left_x = ori_transform[0]  # 左上角x坐标
    w_e_pixel_resolution = ori_transform[1] # 东西方向像素分辨率
    top_left_y = ori_transform[3] # 左上角y坐标
    n_s_pixel_resolution = ori_transform[5] # 南北方向像素分辨率
    
    # 根据反射变换参数计算新图的原点坐标
    top_left_x = top_left_x + offset_x * w_e_pixel_resolution
    top_left_y = top_left_y + offset_y * n_s_pixel_resolution
    
    # 将计算后的值组装为一个元组,以方便设置
    dst_transform = (top_left_x, ori_transform[1], ori_transform[2], top_left_y, ori_transform[4], ori_transform[5])
    
    # 设置裁剪出来图的原点坐标
    out_ds.SetGeoTransform(dst_transform)
    
    # 设置SRS属性(投影信息)
    out_ds.SetProjection(in_ds.GetProjection())
    
    # 写入目标文件
    out_ds.GetRasterBand(1).WriteArray(out_band1)
    out_ds.GetRasterBand(2).WriteArray(out_band2)
    out_ds.GetRasterBand(3).WriteArray(out_band3)
    
    # 将缓存写入磁盘
    out_ds.FlushCache()
    print("FlushCache succeed")
    del out_ds
    

    3 总结

    如果需要批量裁剪,可以使用代码实现,这样更简单,时间也更短;但如果只是少量裁剪几个不同区域的数据,建议使用PIE-Basic,因为Python代码裁剪单张图片的时间要比使用PIE-Basic手动裁剪时间更长!!!

    更多相关内容
  • 假设一个二值图像包含一个 1 cm x 1cm 的正方形,然后提供 xlim 为 [0,1] 和 ylim 为 [0,1],该函数将所有白色像素从输入图像像素坐标转换为实际物理坐标 [c1 ,c2]。
  • 对不同的轮廓进行提取,并计算X、Y坐标,并存储到txt文件中 *读取图片 read_image (Image, '1-2.jpg') * * 关闭窗口 dev_close_window () get_image_size (Image, Width, Height) dev_open_window (0, 0, Width, ...

    1 halcon简要指导

    在这里插入图片描述

    2 实现

    对不同的轮廓进行提取,并计算X、Y坐标,并存储到txt文件中
    【数据和代码下载】

    *读取图片
    read_image (Image, '1-2.jpg')
    * 
    * 关闭窗口
    dev_close_window ()
    get_image_size (Image, Width, Height)
    dev_open_window (0, 0, Width, Height, 'black', WindowHandle)
    * 
    * Segment a region containing the edges
    *基于全局阈值的图像快速阈值化
    fast_threshold (Image, Region, 0, 120, 7)
    *获取一个边界区域
    boundary (Region, RegionBorder, 'inner')
    
    *用圆形结构元素扩张一个区域。
    dilation_circle (RegionBorder, RegionDilation, 3.5)
    
    *获得特定区域Region位置的图像
    reduce_domain (Image, RegionDilation, ImageReduced)
    
    *提取亚像素精密边缘轮廓
    edges_sub_pix (ImageReduced, Edges, 'canny', 2, 20, 60)
    
    * dev_display (Edges)
    *计算个数,
    count_obj (Edges, Number)
    
    * 数字对应第几个轮廓,图2 检测出来总共有6个,图1只有一个轮廓.
    
    * 计算第1个轮廓的坐标
    select_obj(Edges,ObjectSelected1,1)
    dev_display (ObjectSelected1)
    get_contour_xld(ObjectSelected1,Row1,Col1)
    * 存储坐标XY值到txt文件中
    open_file('Img2_XY_contours_1.txt','output',FileHandle)
    fwrite_string (FileHandle,Row1+','+Col1+'\n')
    *计算第2个轮廓的坐标
    select_obj(Edges,ObjectSelected2,2)
    dev_display (ObjectSelected2)
    get_contour_xld(ObjectSelected2,Row2,Col2)
    open_file('Img2_XY_contours_2.txt','output',FileHandle)
    fwrite_string (FileHandle,Row2+','+Col2+'\n')
    *计算第3个轮廓的坐标
    select_obj(Edges,ObjectSelected3,3)
    dev_display (ObjectSelected3)
    get_contour_xld(ObjectSelected3,Row3,Col3)
    open_file('Img2_XY_contours_3.txt','output',FileHandle)
    fwrite_string (FileHandle,Row3+','+Col3+'\n')
    *计算第4个轮廓的坐标
    select_obj(Edges,ObjectSelected4,4)
    dev_display (ObjectSelected4)
    get_contour_xld(ObjectSelected4,Row4,Col4)
    open_file('Img2_XY_contours_4.txt','output',FileHandle)
    fwrite_string (FileHandle,Row4+','+Col4+'\n')
    *计算第5个轮廓的坐标
    select_obj(Edges,ObjectSelected5,5)
    dev_display (ObjectSelected5)
    get_contour_xld(ObjectSelected5,Row5,Col5)
    open_file('Img2_XY_contours_5.txt','output',FileHandle)
    fwrite_string (FileHandle,Row5+','+Col5+'\n')
    *计算第6个轮廓的坐标
    select_obj(Edges,ObjectSelected6,6)
    dev_display (ObjectSelected6)
    get_contour_xld(ObjectSelected6,Row6,Col6)
    open_file('Img2_XY_contours_6.txt','output',FileHandle)
    fwrite_string (FileHandle,Row6+','+Col6+'\n')
    

    在这里插入图片描述

    展开全文
  • 在OpenGL中,所有的图形都是3D的,所有的2D图形都是从3D转过来的,转化的方法是通过一个叫图形管道的东西,你输入一个3D坐标,就立马给你转换成2D 像素。 转换过程分两部: 1、3D坐标转2D 2、2D坐标转成有颜色的像素...

    OpenGL是一个图形接口函数库,他是用来跟GPU驱动打交道的。

    在这里插入图片描述
    在OpenGL中,所有的图形都是3D的,所有的2D图形都是从3D转过来的,转化的方法是通过一个叫图形管道的东西,你输入一个3D坐标,就立马给你转换成2D 像素。

    转换过程分两部:
    1、3D坐标转2D
    2、2D坐标转成有颜色的像素

    这个转换并渲染的过程,要用到一个叫shaders(着色器)的东西,实际上他不是个东西,只是个小程序,你用GL shading language写成的,给GPU去执行的程序罢了。
    有些shaders是我们可以自主编写的,如下图蓝色部分:
    在这里插入图片描述
    如果再细分的话:
    有很多步,比如
    第一个,Vertex shader,接收一个叫Vertex Data的数组,来存储3D坐标、颜色、渲染方式等,主要工作是把3D坐标 转为 “特别” 的3D坐标,并对vertex值做个 “基础” 改变。如上图,原语装配阶段将顶点着色器中构成原语 的所有顶点 (如果GL_POINTS被选择,则为顶点) 作为输入,并将给定的原语形状中的 所有点组装起来;在这个例子中是一个三角形。

    第二个,Shape shader,我们无法操控,直接送到几何 shader

    第三个,几何 Shader,接受一个顶点集合作为输入,它形成一个原语,并且有能力通过发射新的顶点来形成新的(或其他)原语来生成其他形状。在本例中,它从给定的形状生成第二个三角形。

    第四个,镶嵌 shader,把给定的原语细分成许多更小的原语。例如,这允许你创建更流畅的环境,通过创建更多的三角形,与player的距离越小。

    第五个,光栅化 shader,无法参与。镶嵌着色器的输出被传递到光栅化阶段,将产生的原语 映射到最终屏幕上对应的像素,从而产生片段着色器使用的片段。在片段着色器运行之前,剪切被执行。剪切会丢弃视图之外的任何片段,从而提高性能
    其中,片段 (fragment)是OpenGL渲染单个像素所需的所有数据

    第六个,片段 shader,主要目的是计算像素的最终颜色,这通常是所有高级OpenGL效果出现的阶段。通常片段着色器包含有关3D场景的数据,它可以用来计算最终的像素颜色(像光,阴影,光的颜色等等)。

    第七个, alpha测试和混合,无法控制。最终的对象会通过alpha测试和混合阶段的阶段。这个阶段检查片段的相应的depth(和stencil)值(稍后会讲到),并用这些值来检查产生的片段是在其他对象的前面还是后面,是否该被丢弃。还会检查alpha值(alpha值定义了一个对象的透明度)并相应地混合这些对象。因此,即使一个像素输出的颜色是在fragment shader中计算出来的,当渲染多个三角形时,最终的像素颜色仍然可能是完全不同的。

    在实际应用中,由于GPU上没有vertex 和 fragment 的shader,我们自定义vertex shader 和 fragment shader,其他选择默认就行了。

    例子:

    GLfloat vertices[] = {
    -0.5f, -0.5f, 0.0f,
    0.5f, -0.5f, 0.0f,
    0.0f, 0.5f, 0.0f
    };
    

    存储了三角形的三个顶点的3D坐标,把每个vertex的坐标称为标准化的设备坐标,NDC,坐标如下:
    在这里插入图片描述
    最终,你的NDC坐标会转化为屏幕坐标。使用glViewport提供的数据,通过viewport转换,您的NDC坐标将被转换为屏幕空间坐标,然后转换为片段 作为你的片段着色器的输入。

    具体的vertex shader 编写思路,把定义好的vertex数组,送到图形管道第一阶段——vertex shader中,原理是,在GPU上开辟内存存储vertex 数据,配置OpenGL如何去操作这个内存、如何把数据送到显卡。
    于是,这个vertex shader 就把我们写到内存的vertex们 逐个处理。

    在编程上,我们通过vertex buffer objects(vertex缓冲区对象)管理GPU内存,好处是一次送一堆,因为从CPU把数据送到显卡是相对慢的,你只要把数据放在GPU内存中,shader就执行很快(不用等)。
    创建vertex缓冲区代码:

    GLuint VBO;
    glGenBuffers(1, &VBO);
    /*
    1是这个缓冲区对象个数,&VBO用来存储缓冲对象名称的数组
    */
    

    OpenGL有很多类型的缓冲区对象,比如,vertex缓冲区对象的缓冲区类型是GL_ARRAY_BUFFER,

    glBindBuffer(GL_ARRAY_BUFFER, VBO);OpenGL允许我们一次绑定到多个缓冲区,只要它们有不同的缓冲区类型。此时,绑定到一个目标上了,我们(在GL_ARRAY_BUFFER目标上)进行的任何缓冲区调用都将用于配置当前绑定的缓冲区,即VBO。

    然后我们可以调用glBufferData函数,将之前定义的顶点数据复制到缓冲区的内存中:

    专门用于将用户定义的数据复制到当前绑定的缓冲区中的函数
    glBufferData(GL_ARRAY_BUFFER, //我们数据进入的缓冲区类型
    sizeof(vertices),//字节计算
     vertices, //自己的数据
     GL_STATIC_DRAW//告诉显卡我们想怎样管理数据
     /*
    GL_STATIC_DRAW: 数据不会改变
    • GL_DYNAMIC_DRAW: 数据会改变很多
    • GL_STREAM_DRAW: 数据在每次draw 完成时,都会改变
    本次测试用例是一个三角型,
    三角形数据在每次渲染调用时都不改变,
    因此选用图上参数。
    */
     );
    

    整理一下,现在把vertex 的数据存到了显卡上,数据由vertex 缓冲区对象VBO 托管,接下来再是创建vertex 和 fragment 的shader了。

    现在的OpenGL 非要你写个vertex 和 fragment shader ,才让你去渲染。

    OK,接下来用GLSL语言写shaders:
    一共分为3部分:
    1、指定OpenGL版本,330=3.3
    2、读取输入的vertex
    3、输出处理的vertex(有个预定义的gl_Position ,vec4,在Main函数的最后段,会自动把vertex shader 输出的数据存到vec4)

    总的来说,输入ver3(3个参数),输出vec4(4个参数)

    #version 330 core
    
    //用于vertex数据的输入,in是关键字,声明要输入vertex属性了
    //属性是position ,位置,
    //创建了一个vec3来存坐标
    layout (location = 0) in vec3 position;
    
    void main()
    {
    gl_Position = vec4(position.x, position.y, position.z, 1.0);
    //最后一个参数叫透视分割position.w。
    }
    
    
    • [ a] 注意:在真实的应用程序中,输入数据通常还没有在规范化的设备坐标中,所以我们首先必须将输入数据转换为OpenGL可见区域中的坐标

    使用shader:

    为了让OpenGL去使用这个shader,必须把他加到程序源码的动态运行库里面,于是就有一下函数提供接口,

     GLuint vertexShader;//shader 对象
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    

    接下来,将着色器的源代码附加到着色器对象并编译着色器

    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    //第二个参数是多少字符串,第三个是shader源码
    glCompileShader(vertexShader);
    /*
    检查编译是否成功
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if(!success)
    {
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
    std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" <<
    infoLog << std::endl;
    }
    */
    

    Fragment Shader:

    用来计算像素输出颜色。
    计算机图形上的颜色用4个参数代表,Red、 Green、 Blue、Alpha(opacity)component(阿尔法_不透明度组件);
    OpenGL和GLSL中,RGBA值都是在0.0~0.1f

    #version 330 core
    //定义输出值
    out vec4 color;
    void main()
    {
    color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
    }
    

    编译fragment shader

    GLuint fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    

    2个shader 都完成编译后,现在就是要把他们两个的着色器对象链接起来,到一个shader program中,用来渲染。

    制作Shader program:

    同理,又需要shader program对象,他是所有shader的结合体。
    把shader链接到shader program中,然后 在渲染对象时 激活shader program 。搞笑的是,这个程序也是用shader激活的。
    而且,是在每次发出渲染调用时,就使用这个激活shader。

    Luint shaderProgram;
    shaderProgram = glCreateProgram();
    

    这个shader程序会输出结果到下一个shader,如果输出的结果与下个shader 不匹配,报错。
    然后,把编译好的shaders们整合到 对象中,再链接他们:

    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    /*
    如果链接不成功
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if(!success) {
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    ...
    }
    */
    

    链接之后,我们就用glUseProgram(),激活program 对象

    glUseProgram(shaderProgram);
    

    在glUseProgram之后的每一次着色器与渲染调用,会使用这个程序对象(因此,着色器)。

    • 不要忘记删除资源:
    • glDeleteShader(vertexShader);
    • glDeleteShader(fragmentShader);

    到这里为止,我们输入vertex数据到了GPU,写了shader告诉GPU如何处理vertex数据,但是,我们并没有告诉OpenGL如何interpret内存中的vertex数据,如何把vertex数据与 vertex shader的属性连接起来。

    现在就告诉OpenGL,必须手动指定 输入数据的哪一部分要放到 顶点着色器 的哪个顶点属性中。这意味着我们必须在渲染之前指定OpenGL应该如何解释顶点数据
    vertex 缓冲区中的数据是这样排列的:
    在这里插入图片描述
    下面就用函数告诉OpenGL,如何用glVertexAttribPointer(),解释vertex 数据(或属性):
    当然,还要告诉OpenGL如何把vertex数据 与 着色器中的vertex 属性建立联系。这会使用到glEnableVertexAttribArray(0);0是属性位置。

    glVertexAttribPointer(0, 
    3,//指定顶点属性的大小。顶点属性是一个vec3,所以它由3个值组成
    GL_FLOAT, //指定数据类型为GL_FLOAT
    GL_FALSE, //是否数据被规范化。如果设置为GL_TRUE,那么值不在0~1之间(对于有符号的数据,则为-1~1)的所有数据都将映射到这些值。我们将其保留在GL_FALSE。
    3 * sizeof(GLfloat),//stride,步幅__它告诉我们连续的顶点属性集之间的空间
    (GLvoid*)0);//位置数据在缓冲区中开始位置的偏移量
    glEnableVertexAttribArray(0);
    /*
    第一个参数指定我们要配置的顶点属性,
    布局的顶点着色器中指定了位置顶点属性的位置(location = 0),
    这将顶点属性的位置设置为0,
    因为我们想要传递数据给这个顶点属性,所以我们传递了0
    */
    

    因此,在OpenGL中创建对象的代码就如下:

    // 0. Copy our vertices array in a buffer for OpenGL to use
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    // 1. Then set the vertex attributes pointers
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (
    GLvoid*)0);
    glEnableVertexAttribArray(0);
    // 2. Use our shader program when we want to render an object
    glUseProgram(shaderProgram);
    // 3. Now draw the object
    someOpenGLFunctionThatDrawsOurTriangle();
    

    Vertex Arrray Object 顶点数组对象:

    顶点数组对象(VAO)可以像VBO对象一样被绑定,从那个点开始的任何后续顶点属性调用都将存储在VAO中。
    好处是,当配置顶点属性指针时,只需调用一次,并且当绘制对象时,只需绑定相应的VAO。这使得在不同的顶点数据和属性配置之间切换就像绑定不同的VAO一样简单。

    刚刚设置的所有状态都存储在VAO中。

    Core OpenGL要求我们使用VAO,这样它就知道如何处理顶点输入。如果我们没有绑定一个VAO, OpenGL很可能会拒绝绘制任何东西

    顶点数组对象存储以下内容:
    1、Calls to glEnableVertexAttribArray or glDisableVertexAttribArray.
    2、Vertex attribute configurations via glVertexAttribPointer.
    3、Vertex buffer objects associated with vertex attributes by calls to glVertexAttribPointer
    在这里插入图片描述

    void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride, int offset)
    将VBO中的数据传递给顶点数组。offset指定该属性在VBO中起始位置的偏移量,单位为byte
    glVertexAttribPointer或VBO只是建立CPU和GPU之间的逻辑连接,从而实现了CPU数据上传至GPU。但是,数据在GPU端是否可见(着色器能否读取到数据),由是否启用了对应的属性决定,这就是glEnableVertexAttribArray的功能,允许顶点着色器读取GPU(服务器端)数据。glEnableVertexAttribArray可以在glVertexAttribPointer之前或之后调用,只要在绘图(glDraw*系列函数)前调用即可。
    引文地址

    可以看到,当VBO获取到缓冲区ID,绑定到顶点数组类型缓冲区,执行完数据复制,就该指定一下数据在哪里,数据格式是什么等信息,让GPU的shader去处理它,于是就有创建VAO,绑定VAO。
    执行VAO绑定之后其后的所有VBO配置都是这个VAO对象的一部分,可以说VBO是对顶点属性信息的绑定,VAO是对很多个VBO的绑定。

    顶点属性glVertexAttribPointer默认是关闭的,使用时要以顶点属性位置值为参数调用glEnableVertexAttribArray开启。如glEnableVertexAttribArray(0);

    Final Triangle:

    好了,我们建立了vertex缓冲区(VBO),也建立了数据格式信息缓冲区(VAO),把数据直接送到了GPU,并用VAO告诉了OpenGL如何把内存的vertex数据解释一下,最后把编译连接好的shader program利用了,于是就开始draw三角形了;

    glUseProgram(shaderProgram);
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
    
    展开全文
  • 像素深度是什么? 像素深度是指存储每个像素所用的位数,RGB三个通道,一个通道存储8位,则三个通道共存储24位。 像素位深度决定了彩色图像的每个像素可能有的颜色数,或者确定灰度图像的每个像素可能有的灰度级数。...

    像素深度是什么?

    像素深度是指存储每个像素所用的位数,RGB三个通道,一个通道存储8位,则三个通道共存储24位。

    像素位深度决定了彩色图像的每个像素可能有的颜色数,或者确定灰度图像的每个像素可能有的灰度级数。

    每个像素使用的信息位数越多,可用的颜色就越多,颜色表现就更准确。

    位深度为 1 的图像的像素有两个可能的值:黑色和白色。
    位深度为 8 的灰度模式图像有 256 个可能的灰色值。

    在arcgis中查询像素值
    可以用识别,(是什么样的影像,像素值就代表了对应的值,如DEM影像的像素值代表了高程,NDVI影像的像素值代表NDVI数值)

    查询像素值

    在envi中查询像素值步骤如下:
    查询像素值
    查询像素值
    该图为栅格数据,5087和4150代表行列号。

    在arcgis中提取像素值以及经纬度步骤:

    由于我采用的数据太大,所以对其进行了重采样,这样可以加快运行速度。我将栅格数据的分辨率改为了2000,也就是图像上一个栅格的大小代表了实地的2000米,采用的技术为双线性内插。

    重采样方法应用:当不同分辩率的影像数据之间进行运算时,需要将栅格大小统一到一个指定的分辩率上,此时就需要对栅格进行重采样。
    重采样

    1、arctoolbox-转换工具-栅格到点(为了将栅格数据转换为点数据,且生成的点位于栅格的中心)
    栅格转点
    Grid_code写的就是我们每个栅格数据,单个像元的DN值,gridcode这一列数据与值提取至点数据中的rastervalue这一列数据相同。
    栅格转点

    2、arctoolbox-提取工具-值提取至点(为了提取出点所在位置对应的栅格的像素值)

    值提取至点
    结果属性表

    注意:提取失败的原因可能是:
    (1)后台运行不稳定,改为前台运行,在地理处理菜单-地理处理选项-取消后台运行,也就是改为了前台运行。
    (2)换为多值提取至点,再次操作
    多值提取至点

    多值和值提取至点的介绍可以查询以下网站https://wenku.baidu.com/view/7fe9ad3858fafab068dc0248.html

    根据我目前的理解:
    多值提取至点,可以输入多个栅格数据或一个多波段的栅格数据,与对应的点数据相匹配,(自己可以命名提取的字段的名称,便于区分),则生成图的属性表中含有以上各栅格数据的像素值。
    比如,利用同一个地区的NDVI数据、DEM数据,则可以生成既含有NDVI字段、又含有高程字段的属性表。

    多值提取至点不会生成新的shapefile文件(值提取至点会生成),而是将想要提取的像素值赋给了点数据,在输入数据(点数据)的属性表中可以查询。

    3、在属性表中新建两个字段,一个放经度,一个放纬度,字段类型选择double(双精度)。
    添加经纬度字段
    计算经纬度:右键–计算几何,X Coor(x坐标)是经度,Y Coor(y坐标)是纬度。
    计算经度如下:
    计算经度
    计算纬度如下:
    计算纬度

    4、将属性表导出,在excel中进行处理

    属性表结果

    导出属性表
    提取x,y坐标的方法和以上一致,不过是将下面的单位(十进制度)改为米或千米,即可。
    提取x,y坐标

    展开全文
  • matlab设置坐标及图例控制 在论文中插图中,需要对图中的字体进行控制,以及线型线宽等方面进行控制,下面介绍matlab的具体操作。 x = linspace(0,1,100); y = 1 - x; z = 1 - x.^2; w = 1 - 6 * x.^2 + 8 * x.^...
  • 假设在Cartesian坐标系统中的一个点P,其坐标为(x, y),它的含义是这个点的水平坐标或者说是水平方向的投影是x,竖直方向是y。而在图像处理当中,对于一个矩阵I,由于默认该矩阵的坐标原点O处于矩阵的左上角,行indx...
  • 在内存消耗方面,numpy数组比Python元组更紧凑。numpy数组使用一个连续的内存块。numpy数组的所有元素必须是声明的类型(例如32位或64位float)。Python tuple不一定使用连续的内存块,tuple的元素可以是任意Python...
  • 从一张命名为1.tiff的文件中读取相应坐标像素值,坐标由命名为c.xlsx 1、读取数据 img=imread=('1.tiff',1); col=xlsread('c.xlsx',1,'c1:c10'); row=xlsread('c.xlsx',1,'r1:r10'); 2、取像素值 for i=1:...
  • 像素检测算法

    2020-03-02 12:41:00
    //统计像素级边缘点个数, 计算梯度值结果将结果至dxy中 unsigned char *pEdge = (unsigned char *)pEdgeImg.data; unsigned char *pMask = (unsigned char *)m_pMaskImg1[nIndex].data; short *pdx = (short *)dx....
  • tap({xTable}, y)但是我不确定是否会在我为yvariables列出的每个x坐标处“点击”。你为什么不确定? 你没有写吗? 如果不是的话,你可以tap一点地写下来,function tapxs(xs, y) for i,x in ipairs(xs) do tap(x,y) ...
  • 像素坐标系坐标原点在图像的左上角,X轴沿着水平方向向右,Y轴竖直向下 图像坐标系坐标原点在图像的中心,X轴沿着水平方向向右,Y轴竖直向下 相机坐标系X轴沿着水平方向向右,Y轴竖直向下,Z轴向前 像素(u,v)和三维...
  • 国内地图坐标
  • Q2:如何添加通达信分时坐标的类型通达信分时坐标三种类型“普通坐标”“10%坐标”“满占坐标”。在分时图点右键,弹出对话框,选择“分时主图坐标”,就可以选择了。也可以使用快捷键“;”进行快速切换。Q...
  • **python + opencv实现提取.png和.jpg图像的像素信息并存储到txt文件中代码**import cv2import numpyimport matplotlib.pyplot as pltimg = cv2.imread(“D:/Desktop/show_example1/train/0/1.jpg” , cv2.IMREAD_...
  • shader数学基础--坐标空间
  • GDAL对影像进行划分网格,并通过像素坐标转换为地理坐标 #include "gdal_priv.h" #include<iostream> #include<fstream> using namespace std; //这里通过结构体来定义从图像中获取到的像素点 typedef...
  • 假设在Cartesian坐标系统中的一个点P,其坐标为(x, y),它的含义是这个点的水平坐标或者说是水平方向的投影是x,竖直方向是y。而在图像处理当中,对于一个矩阵I,由于默认该矩阵的坐标原点O处于矩阵的左上角,行indx...
  • C#中关于坐标获取

    2019-12-05 01:34:17
    在实际应用中,发现存在一个问题,这个坐标在X轴上始终存在8个像素的间距。这句话什么意思呢?就是说,当我把窗口左侧紧贴屏幕左侧边缘的时候,显示的坐标为X:-8。这就好像有一个无形的边距一样。导致我没法直接用...
  • 将一张灰度化二值化后的的一张黑色图片上的一个白色亮点坐标提取出来,到txt文件中,用c++如何实现?很着急,谢谢大家了。
  • 在实践过程中,通过测试代码,我发现基于BufferedImage可以有两种获取像素矩阵的方式,但需要注意像素点的保存顺序问题。具体表现在:本例中的图片是一副彩色图片(博客头像),大小为425*292,即宽度(Width)为425,...
  • 2.将读取到的坐标存到point里边 3.讲point  pushback  到vector里边 4.关闭文件流对象 ____________________________________________________________________________________________________________ 程序代码...
  • 代码结构 main/gener_alldata.cpp : 用于生成imu数据,相机轨迹,特征点像素坐标,特征点的3d坐标 src/paramc.h:imu噪声参数,imu频率,相机内参数等等 src/camera_model.cpp:相机模型,调用的svo,目前代码里这...
  • C语言数字图像处理---1.1图像的像素格式与图像读写

    万次阅读 多人点赞 2019-12-25 10:06:22
     在Fig.3中,对于任意像素P0,如果它是黑色像素,那么P0=(R=0,G=0,B=0),白色P0=(R=255,G=255,B=255),通常我们用一个RGB坐标轴的三维坐标来表示,即黑色P0(0,0,0),白色P0(255,255,255)。这就是24位彩色图像中像素...
  • 由广播星历计算GNSS卫星坐标前言读取文件计算卫星坐标可视化静态文本变成透明的(通过类向导添加):执行如下操作改变背景小结 前言 本文是一个简单的由广播星历计算GNSS卫星坐标的程序,可以作为一个仅用于计算坐标...
  • 在MATLAB中,用句柄来标识对象,通过句柄来访问相应对象的属性:在MATLAB系统中建立—个对象,系统就会建立—个映射该对象的句柄,用于诸相应对象的属性。 例1:绘制多个图形,并保存图形句柄。 t = 0:pi/10:2*pi; ...
  • 关于图像坐标系与行列宽高的关系感到纠结,但是似乎没有更好的处理方法了,其对应关系大致如下(切记 图像中没有 长宽 一说,只有宽高) 常说的一张图片分辨率640480,对应的图片是widthheight,OpenCV处理时一般对应...
  • javascript中常用坐标属性 MouseEvent(鼠标事件)属性 都是MouseEvent对象下的属性,必须用该对象调用(只读) MouseEvent:当鼠标事件触发后都会产生此对象,该对象记录着鼠标触发事件时的所有属性 例图: 其常用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,094
精华内容 4,037
关键字:

存像素坐标