Controles de coordenada Z

Estos controles de calidad de guiones.py comprueban la coordenada Z de los vértices de la geometría analizada. La página Repositorio de controles de calidad en Python explica cómo se instala el archivo y cómo se asigna un control a un código.

Todos devuelven un GeometryError con las coordenadas del vértice que falla, salvo los dos controles de curvas maestras y finas, que no indican coordenadas.

Evolución de la Z a lo largo de la geometría

Estos controles no tienen parámetros propios. Devuelven el error en el primer vértice que no cumple la condición.

debe_tener_todos_los_vertices_con_la_misma_coordenada_z compara primero la Z mínima y la Z máxima de la geometría con digi3d.same_coordinates, que tiene en cuenta la tolerancia configurada. Si son iguales, no hay error. Si no lo son, busca el primer vértice cuya Z es distinta de la del primer vértice, con una comparación exacta.

@quality_control()
def debe_tener_todos_los_vertices_con_la_misma_coordenada_z(geometry, adding_geometry, code_index):
    'Comunica un error si localiza un vértice con la coordenada Z distinta de la del primer vértice'
    if digi3d.same_coordinates(geometry.min[2], geometry.max[2]):
        return

    zInicial = geometry[0][2]
    for coordenada in geometry:
        if coordenada[2] != zInicial:
            return digi3d.GeometryError('Las geometrías con este código deben tener todos los vértices con la misma coordenada Z', coordenada)

Curvas maestras y finas

Estos controles leen la equidistancia de la propiedad equidistance de la ventana de dibujo, que corresponde a la variable EQUIDISTANCIA. Una curva maestra es una de cada cinco curvas.

La comprobación usa el operador % sin tolerancia. Con equidistancias decimales, como 0,1, el resto de la división puede no ser exactamente 0 por el redondeo de los números en coma flotante.

def es_maestra(coordenada_z, equidistancia, intervalo_maestras=5):
    if not es_curva_fina_o_maestra(coordenada_z, equidistancia):
        return False

    return 0 == coordenada_z % (intervalo_maestras * equidistancia)

Diferencia con el modelo digital del terreno

Estos controles proyectan cada vértice sobre el terreno con el método project de la ventana de dibujo. Si un vértice no se puede proyectar, el control lo salta. El parámetro distancia es la diferencia de Z permitida. El control devuelve el error en el primer vértice que no cumple la condición.

Los dos últimos controles convierten cada Z con int(), que elimina los decimales, antes de restar.

for coordenada in geometry:
    z_proyectada = v.project(coordenada)

    if z_proyectada is None:
        continue

    distancia_calculada = abs(z_proyectada - coordenada[2])
    if distancia_calculada > distancia:
        return digi3d.GeometryError('Vértice de la geometría con una diferencia en Z con respecto al MDT de: {} que es superior a: {}'.format(distancia_calculada, distancia), coordenada)

Diferencia de Z donde se tocan las líneas

Los controles al_tocar_lineas_debe_haber_una_diferencia_de_z_… reciben dos parámetros:

El control toma las geometrías no borradas que tienen esos códigos y cuya caja envolvente en planta se solapa con la de la geometría analizada. Después llama a digi3d.get_intersections, que devuelve los vértices de la geometría analizada que coinciden en planta con un vértice de otra geometría. Un cruce entre dos segmentos sin vértice común no es un punto de contacto para estos controles. En cada punto de contacto, el control calcula el valor absoluto de la diferencia entre la Z del vértice de cada geometría.

Los cinco controles devuelven una lista con un GeometryError por cada punto de contacto que falla, con las coordenadas del vértice de la geometría analizada. En tiempo real devuelven solo el primero.

intersecciones = digi3d.get_intersections(geometry, candidatos)
for coordenadas_interseccion in intersecciones:
    geometrias_que_llegan_a_esta_interseccion = intersecciones[coordenadas_interseccion]
    vertice_geometria_analizando = geometrias_que_llegan_a_esta_interseccion[geometry]
    coordenada_de_geometria_analizando = geometry[vertice_geometria_analizando]
    coordenada_z_comparar = coordenada_de_geometria_analizando[2]

    for otra_geometria in geometrias_que_llegan_a_esta_interseccion:
        if otra_geometria == geometry:
            continue

        vertice_otra_geometria = geometrias_que_llegan_a_esta_interseccion[otra_geometria]
        coordenada_z_otra_geometria = otra_geometria[vertice_otra_geometria][2]

        diferenciaZ = abs(coordenada_z_otra_geometria - coordenada_z_comparar)
        if diferenciaZ >= tolerancia:
            errores_detectados.append(digi3d.GeometryError("Las geometrías se tocan con una diferencia en la coordenada Z de {} (superior o igual a {})".format(diferenciaZ, tolerancia), coordenada_de_geometria_analizando))

            if adding_geometry:
                return errores_detectados

return errores_detectados

Véase también

• Repositorio de controles de calidad en Python
• DrawingView: project y equidistance.
• Funciones del módulo digi3d: get_intersections y same_coordinates.