User:DressyPear4/SepararPoligonosGrudados

From OpenStreetMap Wiki
Jump to navigation Jump to search

Separar linhas/polígonos grudados

Facilita a separação de nós entre linhas ou polígonos grudados, a seleção pode ser feita entre linha/linha - linha/polígono - polígono/polígono.

Como funciona?

  • Selecione uma linha e um polígono
  • Defina a distância da separação
    • Ao selecionar Linha/Polígono, o id do nó é preservado na linha
    • Ao selecionar Polígono/Polígono, o id do nó é preservado na primeira seleção

Demonstração

Imagem.gif, clique para visualizar.

Código

from org.openstreetmap.josm.gui import MainApplication, Notification
from org.openstreetmap.josm.data.osm import DataSet, Way, Node
from org.openstreetmap.josm.data.coor import LatLon, EastNorth
from org.openstreetmap.josm.data.projection import ProjectionRegistry
from org.openstreetmap.josm.data import UndoRedoHandler
from org.openstreetmap.josm.command import ChangeNodesCommand, AddCommand, SequenceCommand
from javax.swing import JOptionPane, JPanel, JLabel, JTextField, BoxLayout, Box, JSpinner, SpinnerNumberModel, UIManager
from java.awt import Dimension
import math


# Utilidades de seleção/UI
def get_selected_valid_ways():
    active_layer = MainApplication.getLayerManager().getActiveDataLayer()
    if not active_layer:
        Notification(u"Nenhuma camada de edição ativa.")\
        .setIcon(UIManager.getIcon("OptionPane.errorIcon")).show()
        return None

    ds = active_layer.getDataSet()
    selected_ways = [w for w in ds.getSelected()
                     if isinstance(w, Way) and not w.isDeleted() and w.getNodesCount() > 1]

    if not selected_ways:
        Notification(u"Nenhuma linha ou polígono selecionada.")\
        .setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
        return None

    return selected_ways

def get_user_input_for_distance():
    panel = JPanel()
    panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
    panel.setPreferredSize(Dimension(450, 100)) 
    panel.add(JLabel(u"Informe a distância de deslocamento (em metros):"))

    spinner = JSpinner(SpinnerNumberModel(10, 0, 50, 5))
    spinner.setPreferredSize(Dimension(10, 10)) 
    panel.add(spinner)
    panel.add(Box.createVerticalStrut(10))

    info_label = JLabel(
        "<html><i><span style='color:#99ff00;'>"
        u"Ao selecionar Linha/Polígono, o id do nó é preservado na linha.<br>"
        u"Ao selecionar Polígono/Polígono, o id do nó é preservado na primeira seleção."
        "</span></i></html>"
    )
    panel.add(info_label)

    result = JOptionPane.showConfirmDialog(
        None, panel, u"Configuração de Deslocamento",
        JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE
    )
    if result == JOptionPane.OK_OPTION:
        return spinner.getValue()
    return None

    if result == JOptionPane.OK_OPTION:
        try:
            distance_str = text_field.getText()
            if not distance_str:
                Notification(u"Distância não informada.")\
                .setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
                return None
            distance = float(distance_str)
            if distance == 0:
                Notification(u"A distância não pode ser zero.")\
                .setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
                return None
            return distance
        except ValueError:
            Notification(u"Entrada inválida. Use número.")\
            .setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
    return None

# Geometria / direção
def is_clockwise(way, projection):
    nodes = way.getNodes()
    area = 0
    for i in range(len(nodes) - 1):
        n1 = projection.latlon2eastNorth(nodes[i].getCoor())
        n2 = projection.latlon2eastNorth(nodes[i + 1].getCoor())
        area += (n2.east() - n1.east()) * (n2.north() + n1.north())
    return area > 0

def calculate_uniform_vector(node, way, distance):
    projection = ProjectionRegistry.getProjection()
    nodes = way.getNodes()
    node_index = -1
    for i, n in enumerate(nodes):
        if n == node:
            node_index = i
            break
    if node_index == -1:
        return None

    prev_index = (node_index - 1) % len(nodes)
    next_index = (node_index + 1) % len(nodes)

    prev_node = nodes[prev_index]
    next_node = nodes[next_index]

    node_en = projection.latlon2eastNorth(node.getCoor())
    prev_en = projection.latlon2eastNorth(prev_node.getCoor())
    next_en = projection.latlon2eastNorth(next_node.getCoor())

    v1x = node_en.east() - prev_en.east()
    v1y = node_en.north() - prev_en.north()
    v2x = next_en.east() - node_en.east()
    v2y = next_en.north() - node_en.north()

    avgx = (v1x + v2x) / 2.0
    avgy = (v1y + v2y) / 2.0

    mag = math.sqrt(avgx * avgx + avgy * avgy)
    if mag < 1e-6:
        return None

    if is_clockwise(way, projection):
        perpx =  avgy / mag * distance
        perpy = -avgx / mag * distance
    else:
        perpx = -avgy / mag * distance
        perpy =  avgx / mag * distance

    return EastNorth(node_en.east() + perpx, node_en.north() + perpy)

def indices_of_node(way, node):
    idxs = []
    nodes = way.getNodes()
    for i in range(len(nodes)):
        if nodes[i] == node:
            idxs.append(i)
    return idxs

# Planejamento em 2 passos
def build_separation_plan(all_selected_ways, distance_meters):
    if not all_selected_ways or distance_meters == 0:
        return {}, []

    ds = all_selected_ways[0].getDataSet()
    projection = ProjectionRegistry.getProjection()

    # Mapeia cada nó para as vias selecionadas que o referenciam
    node_to_selected_referrers = {}
    for way in all_selected_ways:
        if way.isDeleted():
            continue
        for node in way.getNodes():
            if node.isDeleted():
                continue
            node_to_selected_referrers.setdefault(node, [])
            if way not in node_to_selected_referrers[node]:
                node_to_selected_referrers[node].append(way)

    # Ajuda a respeitar a "primeira selecao" entre polígonos
    selected_order_index = {w: i for i, w in enumerate(all_selected_ways)}

    plan_per_way = {}
    add_nodes = []

    for original_node, ways_using in node_to_selected_referrers.items():
        if original_node.isDeleted():
            continue

        if len(ways_using) <= 1:
            continue

        polygons = [w for w in ways_using if w.isClosed()]
        lines    = [w for w in ways_using if not w.isClosed()]
        polygons.sort(key=lambda w: selected_order_index.get(w, 10**9))

        # Caso 1: Linha + Polígono -> substituir nos polígonos, preservar na(s) linha(s)
        if lines and polygons:
            for poly in polygons:
                pos_en = calculate_uniform_vector(original_node, poly, distance_meters)
                if pos_en is None:
                    continue
                new_ll = projection.eastNorth2latlon(pos_en)
                new_node = Node(new_ll)

                idxs = indices_of_node(poly, original_node)
                if not idxs:
                    continue 

                plan_per_way.setdefault(poly, [])
                plan_per_way[poly].append({'indices': idxs, 'new_node': new_node})
                add_nodes.append(new_node)

        # Caso 2: Polígono + Polígono -> preserva no primeiro polígono (pela ordem de seleção),substitui nos demais.
        elif polygons and not lines:
            if len(polygons) < 2:
                continue
            preserved_poly = polygons[0]
            for poly in polygons[1:]:
                pos_en = calculate_uniform_vector(original_node, poly, distance_meters)
                if pos_en is None:
                    continue
                new_ll = projection.eastNorth2latlon(pos_en)
                new_node = Node(new_ll)

                idxs = indices_of_node(poly, original_node)
                if not idxs:
                    continue

                plan_per_way.setdefault(poly, [])
                plan_per_way[poly].append({'indices': idxs, 'new_node': new_node})
                add_nodes.append(new_node)

        else:
            continue

    return plan_per_way, add_nodes

def apply_separation_plan(plan_per_way, add_nodes):
    if not plan_per_way and not add_nodes:
        return False

    cmds = []

    seen = set()
    for node in add_nodes:
        if node in seen:
            continue
        seen.add(node)
        ds = MainApplication.getLayerManager().getEditDataSet()
        if ds is None:
            continue
        cmds.append(AddCommand(ds, node))

    for way, entries in plan_per_way.items():
        current = list(way.getNodes())
        replaced_any = False

        for entry in entries:
            idxs = entry['indices']
            new_node = entry['new_node']
            for idx in idxs:
                if 0 <= idx < len(current):
                    if current[idx] is not new_node:
                        current[idx] = new_node
                        replaced_any = True

        if replaced_any:
            cmds.append(ChangeNodesCommand(way, current))

    if cmds:
        seq = SequenceCommand("Separar nós compartilhados (2 passos)", cmds)
        UndoRedoHandler.getInstance().add(seq)
        return True

    return False

# Validação da seleção
def validate_selection(ways):
    if not ways or len(ways) < 2:
        Notification(
            "Selecione pelo menos dois caminhos.\n"
            u"Pode ser dois polígonos ou um polígono e uma linha."
        ).setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
        return False

    has_polygon = any(w.isClosed() for w in ways)
    has_line = any(not w.isClosed() for w in ways)

    if not has_polygon or (not has_line and len([w for w in ways if w.isClosed()]) < 2):
        Notification(
            u"Selecao inválida.\n"
            u"Deve conter dois polígonos ou um polígono e uma linha."
        ).setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
        return False

    # Verifica se cada geometria compartilha pelo menos um nó com outra
    way_nodes_list = [set(w.getNodes()) for w in ways]
    for i, nodes_a in enumerate(way_nodes_list):
        connected = any(nodes_a & nodes_b for j, nodes_b in enumerate(way_nodes_list) if i != j)
        if not connected:
            Notification(
                u"Uma ou mais geometrias não compartilham nós com as outras.\n"
                u"A separação exige interseção de nós entre as geometrias selecionadas."
            ).setIcon(UIManager.getIcon("OptionPane.warningIcon")).show()
            return False

    return True

# Main
def main():
    ways = get_selected_valid_ways()
    if not ways:
        return

    if not validate_selection(ways):
        return

    distance = get_user_input_for_distance()
    if distance is None:
        return

    plan_per_way, add_nodes = build_separation_plan(ways, distance)
    applied = apply_separation_plan(plan_per_way, add_nodes)

    if applied:
        Notification(u"Separação concluída!")\
        .setIcon(UIManager.getIcon("OptionPane.informationIcon")).show()
    else:
        Notification(u"Nenhuma alteração necessária (nada para separar).")\
        .setIcon(UIManager.getIcon("OptionPane.informationIcon")).show()

main()
Retrieved from "https://wiki.openstreetmap.org/w/index.php?title=User:DressyPear4/SepararPoligonosGrudados&oldid=2924084"