Utilizando Python para determinação de Seções Transversais

 Em um mundo cada vez mais orientado por dados, a capacidade de manipular e interpretar informações geográficas se tornou uma habilidade indispensável em diversas áreas, desde urbanismo e geologia até logística e planejamento ambiental. A tecnologia de Sistemas de Informações Geográficas (SIG) nos permite visualizar, analisar e interpretar dados para compreender relações, padrões e tendências espaciais. Neste contexto, o processamento de dados geográficos através de linguagens de programação como o Python oferece uma flexibilidade incrível e poderosas ferramentas para análise espacial.

Um dos formatos mais comuns para armazenar e compartilhar dados geográficos é o KML (Keyhole Markup Language), frequentemente empacotado como arquivos KMZ para compactação. Esses formatos são amplamente utilizados em aplicações como o Google Earth para exibir informações geográficas em um mapa 3D. A manipulação desses arquivos para análise e geração de novos dados geográficos pode ser essencial em várias aplicações práticas.

Objetivo

O objetivo deste tutorial é demonstrar como ler, processar e manipular dados geográficos contidos em arquivos KMZ utilizando Python, uma linguagem de programação poderosa e acessível. Especificamente, vamos focar em um caso de uso prático: ler um arquivo KMZ para extrair coordenadas geográficas, calcular pontos equidistantes ao longo de uma linha definida por estas coordenadas e, posteriormente, gerar linhas perpendiculares em cada um desses pontos. Este processo é particularmente útil em estudos de alinhamento, planejamento urbano, ou em análises geológicas e ambientais.

Ao final deste tutorial, você será capaz de entender e aplicar conceitos básicos de geoprocessamento usando Python, incluindo a leitura de arquivos KMZ, o cálculo de pontos equidistantes em uma linha geográfica e a criação de linhas perpendiculares em pontos específicos. Este conhecimento pode ser a base para uma variedade de outras aplicações em geoprocessamento e análise espacial, abrindo portas para uma análise mais aprofundada e personalizada de dados geográficos.

Desenvolvimento: Delimitando Seções para Levantamentos Batimétricos

No contexto de levantamentos batimétricos, que visam mapear o fundo de corpos d'água para entender melhor sua profundidade e topografia, a precisão na delimitação de seções transversais é fundamental. Essas seções permitem realizar medições detalhadas e consistentes ao longo de áreas específicas, facilitando a compreensão da morfologia subaquática e auxiliando em diversas aplicações, como na engenharia de reservatórios, estudos ambientais e planejamento de infraestruturas hídricas.

O desafio prático enfrentado neste cenário envolve a criação de seções transversais equidistantes ao longo de um eixo representativo, como o caminhamento de um reservatório. Para isso, foi desenvolvido um código em Python, capaz de manipular dados geográficos contidos em arquivos KMZ. Este formato é comumente utilizado para armazenar dados geoespaciais devido à sua compatibilidade com diversos sistemas de informações geográficas, como o Google Earth.

A solução proposta pelo código permite identificar o eixo central do reservatório e, a partir dele, gerar automaticamente linhas perpendiculares em intervalos equidistantes. Estas linhas funcionam como seções para os levantamentos batimétricos, definindo com precisão as áreas onde as medições serão realizadas. Esta abordagem não apenas aumenta a eficiência do processo de levantamento, mas também garante uma maior precisão e consistência dos dados coletados.

Nas próximas seções deste artigo, detalharemos a implementação e a lógica por trás do código. Abordaremos desde a leitura dos dados geográficos no formato KMZ, passando pelo cálculo dos pontos equidistantes no eixo do reservatório, até a criação das seções transversais perpendiculares. Esta explicação não só proporcionará uma compreensão clara do processo de delimitação de seções para levantamentos batimétricos, mas também demonstrará a flexibilidade e eficácia do Python no tratamento de dados geoespaciais em desafios de engenharia e ambientais.

Materiais e Métodos

A imagem a seguir mostra o eixo do reservatório desenhando no Google Earth.

Foram definidas então as fase e a logica de funcionamento do script:

Importações e Dependências

• math: Biblioteca padrão para operações matemáticas.
• zipfile: Para lidar com arquivos KMZ, que são basicamente arquivos KML compactados.
• pykml: Uma biblioteca para analisar arquivos KML.
• simplekml: Usada para criar arquivos KML/KMZ.
• geopy.distance: Para calcular distâncias entre coordenadas geográficas.

Função ler_kmz

• Objetivo: Extrair coordenadas de um arquivo KMZ.
• Como Funciona: Abre um arquivo KMZ, extrai o KML interno e analisa as coordenadas do LineString.

Função calcular_azimute

• Objetivo: Calcula o azimute entre dois pontos geográficos.
• Como Funciona: Utiliza fórmulas matemáticas para calcular o azimute com base nas latitudes e longitudes.

Função interpolar_pontos_geodesicos

• Objetivo: Interpolar pontos entre vértices de uma linha com uma distância especificada.
• Como Funciona: Calcula pontos ao longo de uma linha, mantendo uma distância constante entre eles.

Função criar_linhas_perpendiculares

• Objetivo: Criar linhas perpendiculares em um ponto dado com base em um azimute e uma distância.
• Como Funciona: Gera dois pontos distantes do ponto central em direções perpendiculares ao azimute dado.

Função calcular_ponto_final

• Objetivo: Calcula o ponto final dada uma distância e um azimute a partir de um ponto inicial.
• Como Funciona: Usa fórmulas de navegação para calcular a posição final.

Função salvar_kmz

• Objetivo: Salvar as seções geradas em um arquivo KMZ.
• Como Funciona: Cria um arquivo KML com as linhas perpendiculares e salva como KMZ.

Fluxo Principal

1. Leitura do Arquivo KMZ: Lê o arquivo "Eixo1.kmz" para obter os vértices.
2. Solicitação da Equidistância: Pede ao usuário para inserir a distância entre seções.
3. Interpolação de Pontos e Criação de Seções: Calcula pontos equidistantes e gera seções perpendiculares.
4. Salvamento do Resultado: Salva as seções geradas em um arquivo KMZ.
5. 
   

Resultados Obtidos

Foram determinadas automaticamente 106 seções transversais com equidistância de 80

metros uma da outra, como representado na imagem a seguir

A seguir e apresentando o script completo.

Código Completo

import math

import zipfile

from pykml import parser

from simplekml import Kml

from geopy.distance import geodesic

def ler_kmz(arquivo_kmz):

    with zipfile.ZipFile(arquivo_kmz, 'r') as zip_ref:

        arquivo_kml = zip_ref.open('doc.kml', 'r')

        root = parser.parse(arquivo_kml).getroot()

        coordenadas = root.Document.Placemark.LineString.coordinates.text

        return [tuple(map(float, coord.split(',')[:2])) for coord in coordenadas.strip().split(' ')]

def calcular_azimute(coord1, coord2):

    lat1, lon1 = coord1

    lat2, lon2 = coord2

    delta_lon = math.radians(lon2 - lon1)

    x = math.cos(math.radians(lat1)) * math.sin(math.radians(lat2)) - math.sin(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.cos(delta_lon)

    y = math.sin(delta_lon) * math.cos(math.radians(lat2))

    azimute = math.atan2(y, x)

    azimute = math.degrees(azimute)

    azimute = (azimute + 360) % 360

    return azimute

def interpolar_pontos_geodesicos(vertices, dist_metros):

    if not vertices or dist_metros <= 0:

        return []

    pontos_interpolados = [vertices[0]]

    dist_acumulada = 0

    for i in range(1, len(vertices)):

        ponto_atual = vertices[i]

        dist_acumulada += geodesic(vertices[i - 1], ponto_atual).meters

        while dist_acumulada >= dist_metros:

            dist_acumulada -= dist_metros

            excesso_dist = dist_acumulada

            fracao = 1 - (excesso_dist / geodesic(vertices[i - 1], ponto_atual).meters)

            

            lat1, lon1 = vertices[i - 1]

            lat2, lon2 = ponto_atual

            lat_inter = lat1 + (lat2 - lat1) * fracao

            lon_inter = lon1 + (lon2 - lon1) * fracao

            lat_inter = max(min(lat_inter, 90), -90)

            lon_inter = max(min(lon_inter, 180), -180)

            pontos_interpolados.append((lat_inter, lon_inter))

            

    if pontos_interpolados[-1] != vertices[-1]:

       pontos_interpolados.append(vertices[-1])

    return pontos_interpolados

def criar_linhas_perpendiculares(ponto, azimute, distancia):

    

    azimute_perpendicular = (azimute + 90) % 360

    azimute_oposto = (azimute_perpendicular + 180) % 360

    ponto1 = calcular_ponto_final(ponto, azimute_perpendicular, distancia / 2)

    ponto2 = calcular_ponto_final(ponto, azimute_oposto, distancia / 2)

    return [ponto1, ponto, ponto2]

def calcular_ponto_final(ponto_inicial, azimute, distancia):

    lat, lon = ponto_inicial

    lat_rad = math.radians(lat)

    lon_rad = math.radians(lon)

    azimute_rad = math.radians(azimute)

    R = 6371 # Raio da Terra em km

    lat_final = math.asin(math.sin(lat_rad) * math.cos(distancia/R) +

                          math.cos(lat_rad) * math.sin(distancia/R) * math.cos(azimute_rad))

    lon_final = lon_rad + math.atan2(math.sin(azimute_rad) * math.sin(distancia/R) * math.cos(lat_rad),

                                     math.cos(distancia/R) - math.sin(lat_rad) * math.sin(lat_final))

    lat_final = math.degrees(lat_final)

    lon_final = math.degrees(lon_final)

    return (lat_final, lon_final)

def salvar_kmz(secoes, arquivo_destino):

    kml = Kml()

    for idx, secao in enumerate(secoes):

        if secao:

            ls = kml.newlinestring(coords=secao)

            ls.name = f"Secao_{idx + 1}"

            ls.extrude = 1

            ls.altitudemode = 'clampToGround'

    kml.savekmz(arquivo_destino, format=False)

# Main

arquivo_kmz = "Eixo1.kmz"

vertices = ler_kmz(arquivo_kmz)

try:

    equidistancia = float(input("Digite a equidistância das seções em metros: "))

except ValueError:

    print("Entrada inválida.")

    exit()

pontos_interpolados = []

for i in range(len(vertices) - 1):

    pontos_interpolados = interpolar_pontos_geodesicos(vertices, equidistancia)

secoes = []

for i in range(1, len(pontos_interpolados)):

    azimute = calcular_azimute(pontos_interpolados[i - 1], pontos_interpolados[i])

    secao = criar_linhas_perpendiculares(pontos_interpolados[i], azimute, 0.500)

    secoes.append(secao)

if secoes:

    nome_base = arquivo_kmz.split('.')[0]

    nome_arquivo_saida = f"{nome_base}_Secoes.kmz"

    salvar_kmz(secoes, nome_arquivo_saida)

    print(f"As seções foram criadas e salvas em {nome_arquivo_saida}.")

    

else:

    print("Não foi possível criar seções.")

Considerações Adicionais

• Este código é um exemplo de como realizar operações de geoprocessamento em Python.
• A precisão do resultado depende da precisão dos dados de entrada e das bibliotecas utilizadas.
• O código pode ser adaptado para diferentes casos de uso, ajustando parâmetros como distância das seções e comprimento das linhas perpendiculares.