Cpp
#include <iostream>
#include <fstream>
#include <string>
#include <regex>

// Function to mirror the coordinates in the Gerber file
void mirrorGerber(const std::string& inputFilePath, const std::string& outputFilePath) {
    std::ifstream inputFile(inputFilePath);
    std::ofstream outputFile(outputFilePath);
    if (!inputFile.is_open() || !outputFile.is_open()) {
        std::cerr << "Error opening file." << std::endl;
        return;
    }

    std::string line;
    std::regex xCoordinatePattern(R"((X[0-9]*))");
    std::smatch match;
    bool hasSeenPercent = false;

    while (std::getline(inputFile, line)) {
        if (line.find('%') != std::string::npos) {
            hasSeenPercent = true;
        }
        
        if (hasSeenPercent && std::regex_search(line, match, xCoordinatePattern)) {
            // Mirror the X coordinates by adding a negative sign
            for (const auto& xMatch : match) {
                size_t pos = line.find(xMatch.str());
                line.insert(pos + 1, "-");
            }
        }
        outputFile << line << "\n";
    }

    inputFile.close();
    outputFile.close();
}

int main() {
    std::string inputFilePath = "archivo.GBL";
    std::string outputFilePath = "archivo_espejado.GBL";

    mirrorGerber(inputFilePath, outputFilePath);

    std::cout << "Gerber file mirrored successfully." << std::endl;

    return 0;
}

1. Abre el archivo de entrada (el archivo Gerber original) y crea el archivo de salida (el archivo Gerber espejado).
2. Busca la presencia del símbolo % para determinar hasta dónde agregar el espejo.
3. Encuentra las coordenadas de X en el archivo y las espeja añadiendo un signo negativo.
4. Guarda las modificaciones en el archivo de salida.

Bash
g++ -o espejar_gerber espejar_gerber.cpp

Bash
./espejar_gerber

Cpp
#include <iostream>
#include <fstream>
#include <string>

// Function to find the last occurrence of '%' in a file
long findLastPercentPosition(const std::string& filepath) {
    std::ifstream file(filepath, std::ios::in);
    if (!file) {
        std::cerr << "Error opening file: " << filepath << std::endl;
        return -1;
    }

    std::string line;
    long lastPos = -1;
    long currentPos = 0;

    while (std::getline(file, line)) {
        if (line.find('%') != std::string::npos) {
            lastPos = file.tellg();
        }
        currentPos = file.tellg();
    }

    file.close();
    return lastPos;
}

// Function to mirror the X-coordinates in a line
std::string mirrorLine(const std::string& line) {
    std::string mirroredLine = line;
    size_t xpos = 0;

    while ((xpos = mirroredLine.find('X', xpos)) != std::string::npos) {
        size_t endpos = mirroredLine.find_first_not_of("0123456789", xpos + 1);
        mirroredLine.insert(xpos + 1, "-");
        xpos = endpos;
    }

    return mirroredLine;
}

// Function to mirror the coordinates in a Gerber file
void mirrorGerberFile(const std::string& inputFilePath, const std::string& outputFilePath) {
    long lastPercentPos = findLastPercentPosition(inputFilePath);
    if (lastPercentPos == -1) {
        std::cerr << "Error: Unable to find '%' in the input file." << std::endl;
        return;
    }

    std::ifstream inputFile(inputFilePath);
    std::ofstream outputFile(outputFilePath);

    if (!inputFile.is_open() || !outputFile.is_open()) {
        std::cerr << "Error opening input or output file." << std::endl;
        return;
    }

    std::string line;
    long currentPos = 0;

    while (std::getline(inputFile, line)) {
        currentPos = inputFile.tellg();
        if (currentPos > lastPercentPos) {
            line = mirrorLine(line);
        }
        outputFile << line << "\n";
    }

    inputFile.close();
    outputFile.close();
}

int main() {
    std::string inputFilePath = "archivo.GBL";
    std::string outputFilePath = "archivo_espejado.GBL";

    mirrorGerberFile(inputFilePath, outputFilePath);

    std::cout << "Gerber file mirrored successfully." << std::endl;

    return 0;
}

1. Define la función findLastPercentPosition para encontrar la última aparición del símbolo % en el archivo.
2. Define la función mirrorLine para agregar un signo negativo a los valores de coordenadas X.
3. Define la función mirrorGerberFile que utiliza las dos funciones anteriores para procesar el archivo de entrada y crear la versión espejada.
4. En main, se especifican los nombres de los archivos de entrada y salida y se llama a la función mirrorGerberFile.

1. Leer el contenido del archivo Gerber.
2. Invertir las coordenadas X.
3. Guardar el nuevo contenido en un archivo Gerber.

Python
import re

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.readlines()

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar todas las coordenadas X en la línea
        x_coords = re.findall(r'X([0-9\-]+)', line)
        for x in x_coords:
            # Invertir la coordenada X
            inverted_x = f'X{-int(x)}'
            # Reemplazar la coordenada en la línea
            line = line.replace(f'X{x}', inverted_x)
        return line

    # Aplicar la inversión a todas las líneas después del último '%'
    in_data = False
    new_gerber_data = []
    for line in gerber_data:
        if '%' in line:
            in_data = True
        if in_data:
            new_gerber_data.append(invert_x(line))
        else:
            new_gerber_data.append(line)

    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.writelines(new_gerber_data)

# Ejemplo de uso
input_file = 'input.gerber'
output_file = 'mirrored_output.gerber'
mirror_gerber_x(input_file, output_file)

1. Lee el archivo Gerber línea por línea.
2. Utiliza una expresión regular para encontrar las coordenadas X.
3. Invierte las coordenadas X.
4. Guarda el nuevo contenido en un archivo de salida.

Python
import re

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X
    processed_data = []
    in_data = False
    for line in gerber_data.split('\n'):
        if line.startswith('%'):  # Detectar el inicio del bloque de datos
            in_data = not in_data
        if in_data:
            processed_data.append(invert_x(line))
        else:
            processed_data.append(line)

    # Unir las líneas procesadas
    new_gerber_data = '\n'.join(processed_data)
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

# Ejemplo de uso
input_file = 'input.gerber'
output_file = 'mirrored_output.gerber'
mirror_gerber_x(input_file, output_file)

1. Lectura del archivo Gerber completo: El uso de file.read() lee todo el contenido del archivo en lugar de línea por línea.
2. Inversión de coordenadas: La función invert_x utiliza una expresión regular para encontrar y reemplazar las coordenadas X.
3. Detección del bloque de datos: Utilizamos el carácter '%' para alternar la entrada y salida del bloque de datos.
4. Procesamiento del bloque de datos: Invertimos las coordenadas X solo dentro del bloque de datos.
5. Escribir el archivo de salida: Guardamos el contenido modificado en un nuevo archivo.

1. Lee el archivo Gerber de entrada entero.
2. Busca el último '%'.
3. Invierte las coordenadas 'X' solo después de esa posición.
4. Guarda el contenido modificado en un nuevo archivo.

Python
import re

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

# Ejemplo de uso
input_file = 'input.gerber'
output_file = 'mirrored_output.gerber'
mirror_gerber_x(input_file, output_file)

print(f"Archivo espejado guardado en {output_file}")

1. Lectura del archivo Gerber completo: Usa file.read() para leer todo el contenido.
2. Buscar el último %: Usa rfind para encontrar la última ocurrencia del carácter '%'.
3. Dividir el archivo: Divide el contenido en dos partes: antes y después del último '%'.
4. Invertir coordenadas X: Usa invert_x para invertir las coordenadas 'X' en la parte después del último '%'.
5. Combinar las partes: Une las dos partes modificadas.
6. Escribir el archivo de salida: Guarda el contenido modificado en un nuevo archivo.

Python
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files(directory):
    # Buscar todos los archivos .GBL en el directorio especificado
    gbl_files = glob.glob(os.path.join(directory, '*.GBL'))

    for gbl_file in gbl_files:
        # Generar el nombre del archivo de salida
        base_name = os.path.basename(gbl_file)
        output_file = os.path.join(directory, base_name.replace('.GBL', '_espejo.GBL'))

        # Procesar el archivo
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

# Ejemplo de uso
directory = 'ruta/al/directorio'
process_all_gbl_files(directory)

1. mirror_gerber_x(input_file, output_file): Es el mismo código que invierte las coordenadas X después del último '%'.
2. process_all_gbl_files(directory):
   • Utiliza glob.glob para encontrar todos los archivos .GBL en el directorio especificado.
   • Genera nombres de archivos de salida con el sufijo _espejo.GBL.
   • Llama a mirror_gerber_x para procesar cada archivo encontrado.

1. Define la variable directory con la ruta al directorio que contiene los archivos .GBL.
2. Llama a process_all_gbl_files(directory) para procesar todos los archivos en ese directorio.

1. Instala Python (si aún no está instalado):

   Sh
   sudo apt-get update
   sudo apt-get install python3

2. Guarda el script. Puedes guardar el script en un archivo, por ejemplo mirror_gerber.py.
3. Proporciónale permisos de ejecución (opcional):

   Sh
   chmod +x mirror_gerber.py

4. Ejecuta el script:

   Sh
   python3 mirror_gerber.py

Python
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files(directory):
    # Buscar todos los archivos .GBL en el directorio especificado
    gbl_files = glob.glob(os.path.join(directory, '*.GBL'))

    for gbl_file in gbl_files:
        # Generar el nombre del archivo de salida
        base_name = os.path.basename(gbl_file)
        output_file = os.path.join(directory, base_name.replace('.GBL', '_espejo.GBL'))

        # Procesar el archivo
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

# Ejemplo de uso
directory = '/ruta/al/directorio/'
process_all_gbl_files(directory)

print("Proceso completado.")

• Ruta del Directorio: Asegúrate de que la ruta del directorio que asignas a la variable directory esté correctamente definida y que tengas permisos de lectura/escritura en dicho directorio.
• Instalación de Python: En la mayoría de las distribuciones de Linux, Python ya viene preinstalado. Puedes verificar la instalación ejecutando python3 --version.
• Ejecución del Script: Llama a python3 seguido del nombre del archivo del script para ejecutarlo.

Python
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files():
    # Obtener el directorio actual
    current_directory = os.getcwd()
    
    # Buscar todos los archivos .GBL en el directorio actual
    gbl_files = glob.glob(os.path.join(current_directory, '*.GBL'))

    for gbl_file in gbl_files:
        # Generar el nombre del archivo de salida
        base_name = os.path.basename(gbl_file)
        output_file = os.path.join(current_directory, base_name.replace('.GBL', '_espejo.GBL'))

        # Procesar el archivo
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

# Ejecutar el procesamiento
process_all_gbl_files()

print("Proceso completado.")

1. Obtener el directorio actual: Utiliza os.getcwd() para obtener el directorio desde el cual se ejecuta el script.
2. Buscar archivos en el directorio actual: Usa glob.glob para buscar archivos .GBL en el directorio actual.
3. Procesar cada archivo encontrado: Genera un nuevo nombre con el sufijo _espejo.GBL y llama a mirror_gerber_x.

1. Abre un terminal.
2. Navega al directorio donde está el script (por ejemplo, mirror_gerber.py) usando cd.
3. Ejecuta el script con Python:

   Sh
   python3 mirror_gerber.py

• Directorio Actual: El script buscará archivos .GBL en el directorio desde el cual se ejecuta el script y generará los archivos espejados en el mismo directorio.
• Permisos: Asegúrate de que tienes permisos de lectura/escritura en el directorio actual y para los archivos .GBL.

Python
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files():
    # Buscar todos los archivos .GBL en el directorio actual
    gbl_files = glob.glob('*.GBL')

    for gbl_file in gbl_files:
        # Generar el nombre del archivo de salida
        base_name = os.path.basename(gbl_file)
        output_file = base_name.replace('.GBL', '_espejo.GBL')

        # Procesar el archivo
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

# Ejecutar el procesamiento
process_all_gbl_files()

print("Proceso completado.")

1. Uso de glob.glob('*.GBL'): Busca todos los archivos .GBL en el directorio actual sin usar rutas absolutas.
2. Generación del nombre del archivo de salida:
   • Utiliza base_name.replace('.GBL', '_espejo.GBL') para generar el nombre del archivo espejado.
3. Procesamiento y generación de archivos:
   • Procesa cada archivo y guarda la versión espejada en el mismo directorio.

1. Guarda el script en un archivo, por ejemplo mirror_gerber.py.
2. Abre un terminal.
3. Navega al directorio donde tienes los archivos .GBL y el script.
4. Ejecuta el script con Python:

   Sh
   python3 mirror_gerber.py

1. Añadir la línea shebang al principio del script de Python.
2. Hacer el archivo ejecutable.
3. Asignar permisos de ejecución.
4. Opcionalmente, crear un lanzador si estás en un entorno de escritorio gráfico.

Python
#!/usr/bin/env python3
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    # Leer el contenido del archivo Gerber
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    # Encontrar la última ocurrencia del caracter '%'
    last_percent_pos = gerber_data.rfind('%')

    # Dividir el archivo en dos partes: antes y después del último '%'
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    # Función para invertir las coordenadas X
    def invert_x(line):
        # Encontrar y reemplazar la coordenada X en la línea
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    # Procesar cada línea para invertir las coordenadas X en la parte después del '%'
    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    # Unir las líneas procesadas
    new_after_last_percent = '\n'.join(processed_data)

    # Combinar ambas partes
    new_gerber_data = before_last_percent + new_after_last_percent
    
    # Escribir el contenido invertido en el nuevo archivo Gerber
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files():
    # Buscar todos los archivos .GBL en el directorio actual
    gbl_files = glob.glob('*.GBL')

    for gbl_file in gbl_files:
        # Generar el nombre del archivo de salida
        base_name = os.path.basename(gbl_file)
        output_file = base_name.replace('.GBL', '_espejo.GBL')

        # Procesar el archivo
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

# Ejecutar el procesamiento
process_all_gbl_files()

print("Proceso completado.")

Sh
chmod +x mirror_gerber.py

1. Crea un archivo de texto con la extensión .desktop, por ejemplo, mirror_gerber.desktop.
2. Edita el archivo y añade el siguiente contenido, reemplazando path/to/mirror_gerber.py con la ruta real del script:

Ini
[Desktop Entry]
Version=1.0
Type=Application
Name=Mirror Gerber
Comment=Execute the mirror Gerber script
Exec=/ruta/a/mirror_gerber.py
Icon=utilities-terminal
Terminal=true

3. Guarda el archivo .desktop y hazlo ejecutable:

   Sh
   chmod +x mirror_gerber.desktop

Sh
pip install pyinstaller

Sh
pyinstaller --onefile mirror_gerber.py

• --onefile: Crea un único archivo ejecutable.
• --noconsole: (Opcional) Si no deseas que se abra la consola (ventana de terminal) al ejecutar el programa en Windows.

Sh
pyinstaller --onefile mirror_gerber.py

Sh
pyinstaller --onefile --noconsole mirror_gerber.py

• En dist/, encontrarás el archivo mirror_gerber (en Linux) o mirror_gerber.exe (en Windows).

1. Instala PyInstaller:

   Sh
   pip install pyinstaller

2. Navega al directorio del script:

   Sh
   cd /ruta/al/directorio

3. Ejecuta PyInstaller:

   Sh
   pyinstaller --onefile mirror_gerber.py

4. Encuentra el ejecutable en la carpeta dist y ejecútalo con doble clic.

Python
#!/usr/bin/env python3
import re
import glob
import os

def mirror_gerber_x(input_file, output_file):
    with open(input_file, 'r') as file:
        gerber_data = file.read()

    last_percent_pos = gerber_data.rfind('%')
    before_last_percent = gerber_data[:last_percent_pos + 1]
    after_last_percent = gerber_data[last_percent_pos + 1:]

    def invert_x(line):
        return re.sub(r'X([0-9\-]+)', lambda match: 'X' + str(-int(match.group(1))), line)

    processed_data = []
    for line in after_last_percent.split('\n'):
        processed_data.append(invert_x(line))

    new_after_last_percent = '\n'.join(processed_data)
    new_gerber_data = before_last_percent + new_after_last_percent
    
    with open(output_file, 'w') as file:
        file.write(new_gerber_data)

def process_all_gbl_files():
    gbl_files = glob.glob('*.GBL')
    for gbl_file in gbl_files:
        base_name = os.path.basename(gbl_file)
        output_file = base_name.replace('.GBL', '_espejo.GBL')
        mirror_gerber_x(gbl_file, output_file)
        print(f"Archivo espejado guardado en {output_file}")

process_all_gbl_files()
print("Proceso completado.")

1. Buscará todos los archivos .GBL en el directorio actual.
2. Procesará cada archivo para invertir las coordenadas X después del último '%'.
3. Guardará los archivos procesados con el sufijo _espejo.GBL.

Cpp
#include <iostream>
#include <fstream>
#include <filesystem>
#include <regex>
#include <string>
#include <vector>

namespace fs = std::filesystem;

std::string invert_x_coordinates(const std::string& after_last_percent) {
    std::regex x_regex("X([0-9\\-]+)");
    return std::regex_replace(after_last_percent, x_regex, [](const std::smatch& match) {
        int x_value = std::stoi(match.str(1));
        return "X" + std::to_string(-x_value);
    });
}

void mirror_gerber_x(const std::string& input_file, const std::string& output_file) {
    // Leer el contenido del archivo Gerber
    std::ifstream infile(input_file);
    if (!infile) {
        std::cerr << "No se puede abrir el archivo: " << input_file << std::endl;
        return;
    }
    std::stringstream buffer;
    buffer << infile.rdbuf();
    std::string gerber_data = buffer.str();
    infile.close();

    // Encontrar la última ocurrencia del caracter '%'
    size_t last_percent_pos = gerber_data.rfind('%');

    if (last_percent_pos == std::string::npos) {
        std::cerr << "No se encontró el caracter '%' en el archivo: " << input_file << std::endl;
        return;
    }

    // Dividir el archivo en dos partes: antes y después del último '%'
    std::string before_last_percent = gerber_data.substr(0, last_percent_pos + 1);
    std::string after_last_percent = gerber_data.substr(last_percent_pos + 1);

    // Invertir las coordenadas X en la parte después del último '%'
    std::string new_after_last_percent = invert_x_coordinates(after_last_percent);

    // Combinar ambas partes
    std::string new_gerber_data = before_last_percent + new_after_last_percent;

    // Escribir el contenido invertido en el nuevo archivo Gerber
    std::ofstream outfile(output_file);
    if (!outfile) {
        std::cerr << "No se puede escribir el archivo: " << output_file << std::endl;
        return;
    }
    outfile << new_gerber_data;
    outfile.close();
}

void process_all_gbl_files() {
    std::vector<std::string> gbl_files;
    
    // Buscar todos los archivos .GBL en el directorio actual
    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.path().extension() == ".GBL") {
            gbl_files.push_back(entry.path().string());
        }
    }

    for (const auto& gbl_file : gbl_files) {
        // Generar el nombre del archivo de salida
        std::string output_file = gbl_file.substr(0, gbl_file.rfind(".GBL")) + "_espejo.GBL";

        // Procesar el archivo
        mirror_gerber_x(gbl_file, output_file);
        std::cout << "Archivo espejado guardado en " << output_file << std::endl;
    }
}

int main() {
    process_all_gbl_files();
    std::cout << "Proceso completado." << std::endl;
    return 0;
}

Sh
g++ -o mirror_gerber mirror_gerber.cpp -std=c++17

Sh
./mirror_gerber

1. Lectura de Archivos: Utilizamos std::ifstream para leer el contenido del archivo Gerber.
2. Inversión de Coordenadas X: Usamos std::regex para buscar y reemplazar las coordenadas X.
3. Escritura de Archivos: Utilizamos std::ofstream para escribir el contenido invertido en el nuevo archivo Gerber.
4. Búsqueda de Archivos .GBL: Utilizamos std::filesystem para encontrar todos los archivos .GBL en el directorio actual.
5. Proceso Principal: Procesa cada archivo .GBL encontrado y genera el archivo espejado correspondiente.

Cpp
#include <iostream>
#include <fstream>
#include <filesystem>
#include <regex>
#include <sstream>
#include <string>
#include <vector>

namespace fs = std::filesystem;

std::string invert_x_coordinates(const std::string& after_last_percent) {
    std::regex x_regex("X([0-9\\-]+)");
    std::string result;
    std::sregex_iterator iter(after_last_percent.begin(), after_last_percent.end(), x_regex);
    std::sregex_iterator end;
    size_t last_pos = 0;

    while (iter != end) {
        std::smatch match = *iter;
        int x_value = std::stoi(match.str(1));
        result += after_last_percent.substr(last_pos, match.position() - last_pos); // Copy all text before the match
        result += "X" + std::to_string(-x_value); // Replace with inverted X
        last_pos = match.position() + match.length(); // Move past the match
        iter++;
    }
    result += after_last_percent.substr(last_pos); // Copy any remaining text after the last match
    return result;
}

void mirror_gerber_x(const std::string& input_file, const std::string& output_file) {
    // Leer el contenido del archivo Gerber
    std::ifstream infile(input_file);
    if (!infile) {
        std::cerr << "No se puede abrir el archivo: " << input_file << std::endl;
        return;
    }
    std::stringstream buffer;
    buffer << infile.rdbuf();
    std::string gerber_data = buffer.str();
    infile.close();

    // Encontrar la última ocurrencia del caracter '%'
    size_t last_percent_pos = gerber_data.rfind('%');

    if (last_percent_pos == std::string::npos) {
        std::cerr << "No se encontró el caracter '%' en el archivo: " << input_file << std::endl;
        return;
    }

    // Dividir el archivo en dos partes: antes y después del último '%'
    std::string before_last_percent = gerber_data.substr(0, last_percent_pos + 1);
    std::string after_last_percent = gerber_data.substr(last_percent_pos + 1);

    // Invertir las coordenadas X en la parte después del último '%'
    std::string new_after_last_percent = invert_x_coordinates(after_last_percent);

    // Combinar ambas partes
    std::string new_gerber_data = before_last_percent + new_after_last_percent;

    // Escribir el contenido invertido en el nuevo archivo Gerber
    std::ofstream outfile(output_file);
    if (!outfile) {
        std::cerr << "No se puede escribir el archivo: " << output_file << std::endl;
        return;
    }
    outfile << new_gerber_data;
    outfile.close();
}

void process_all_gbl_files() {
    std::vector<std::string> gbl_files;
    
    // Buscar todos los archivos .GBL en el directorio actual
    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.path().extension() == ".GBL") {
            gbl_files.push_back(entry.path().string());
        }
    }

    for (const auto& gbl_file : gbl_files) {
        // Generar el nombre del archivo de salida
        std::string output_file = gbl_file.substr(0, gbl_file.rfind(".GBL")) + "_espejo.GBL";

        // Procesar el archivo
        mirror_gerber_x(gbl_file, output_file);
        std::cout << "Archivo espejado guardado en " << output_file << std::endl;
    }
}

int main() {
    process_all_gbl_files();
    std::cout << "Proceso completado." << std::endl;
    return 0;
}

1. Función invert_x_coordinates: Utiliza un iterador regex para encontrar coincidencias de coordenadas X, invierte el valor, y construye la cadena resultante manualmente.
2. Lectura y escritura de archivos: Utiliza std::ifstream y std::ofstream para leer y escribir archivos.
3. Iteración sobre archivos: Utiliza std::filesystem::directory_iterator para encontrar y procesar todos los archivos .GBL en el directorio actual.

1. Guarda el código en un archivo, por ejemplo mirror_gerber.cpp.
2. Compílalo usando g++:

   Sh
   g++ -o mirror_gerber mirror_gerber.cpp -std=c++17

3. Ejecuta el programa:

   Sh
   ./mirror_gerber