Traducción de código Morse con Aspose.Font | .NET

Traducción de código Morse con Aspose.Font para.NET

¿Qué es la traducción al código Morse?

Esta es una funcionalidad que le permite:

Objetivo	Cómo funciona
Codificar texto plano en glifos de código Morse de una fuente (o una imagen de mapa de bits)	`IFontMorseEncoder` convierte caracteres en una secuencia de símbolos de punto (`.`) y guión (`-`) y los asigna a los identificadores de glifo del `IFont` proporcionado.
Decodificar una cadena que ya contiene símbolos Morse y convertirla en texto legible	`IFontMorseDecoder` realiza la operación inversa.
Renderizar los glifos codificados directamente a PNG (o cualquier formato ráster compatible con Aspose.Font)	Las sobrecargas que aceptan parámetros de renderizado (`LineSpacingType`, tamaño de la imagen, etc.) crean la imagen automáticamente.

La característica se introdujo en Aspose.Fontfor.NET23.10 (FONTNET‑602 – Compatibilidad con codificación de código Morse).

¿Por qué usarlo?

Solución Pure‑C#: sin bibliotecas externas ni dependencias a nivel de sistema operativo.
Funciona con cualquier fuente que contenga los glifos requeridos (TrueType, OpenType, CFF…).
La heurística incorporada selecciona automáticamente el alfabeto correcto (latín, griego, cirílico, etc.) cuando lo omites.
Tanto texto → ID de glifo (útil para canalizaciones de representación personalizadas) como ID de glifo → PNG están disponibles de forma inmediata.
Totalmente cubierto por el soporte de Aspose (foros, documentos, demostración en vivo).

Empezando

1 Instale el paquete NuGet

1dotnet add package Aspose.Font

2 Agregar espacios de nombres (C#)

1using Aspose.Font;
2using Aspose.Font.TextUtils;
3using Aspose.Font.Renderers;   // for PNG rendering
4using Aspose.Font.Rendering;   // for LineSpacingType

Descripción general de la API

1 Fábrica – punto de entrada

Método	Devuelve	Descripción
`TextUtilsFactory.GetFontMorseEncoder()`	`IFontMorseEncoder`	Codificador que funciona con una instancia de `IFont`
`TextUtilsFactory.GetMorseEncoder()`	`IMorseEncoder`	Codificador que produce cadenas Morse simples (sin fuente)
`TextUtilsFactory.GetFontMorseDecoder()`	`IFontMorseDecoder`	Decodificador que convierte glifos en texto
`TextUtilsFactory.GetMorseDecoder()`	`IMorseDecoder`	Decodificador para cadenas Morse simples

La fábrica vive en Aspose.Font.Factories.TextUtilsFactory (agregado en 23.10).

2 interfaces principales

`IFontMorseEncoder`

 1public interface IFontMorseEncoder
 2{
 3    IEnumerable<int> Encode(string text, IFont font,
 4                            char dot = '.', char dash = '-');
 5
 6    IEnumerable<int> Encode(string text, IFont font,
 7                            MorseAlphabets alphabet,
 8                            char dot = '.', char dash = '-');
 9
10    byte[] Encode(string text, IFont font,
11                  double fontSize,
12                  LineSpacingType spacing,
13                  int width, int height,
14                  char dot = '.', char dash = '-');
15
16    byte[] Encode(string text, IFont font,
17                  double fontSize,
18                  LineSpacingType spacing,
19                  int width, int height,
20                  MorseAlphabets alphabet,
21                  char dot = '.', char dash = '-');
22}

`IFontMorseDecodificador`

1public interface IFontMorseDecoder
2{
3    string Decode(string morseText, IFont font,
4                  char dot = '.', char dash = '-');
5
6    string Decode(string morseText, IFont font,
7                  MorseAlphabets alphabet,
8                  char dot = '.', char dash = '-');
9}

`IMorseEncoder/IMorseDecoder`

Estos funcionan solo con cadenas sin formato (sin fuentes involucradas). Úsalos cuando solo necesites secuencias de “puntos y rayas”.

3 Enumera de soporte: `MorseAlphabets`

Valor	Escritura
`Latín`	Inglés y la mayoría de los idiomas occidentales
`Griego`	Letras griegas
`Cirílico`	Ruso, búlgaro, etc.
`Hebreo`	Letras hebreas
`Árabe`	Escritura árabe
`Portugués`	Símbolos específicos del portugués
`Kurdo`	Letras kurdas
`Persa`	Letras persas/farsi

Si omite la enumeración, el codificador intenta la detección automática.

Ejemplos prácticos

 Codificar en ID de glifos

 1// Load any TrueType/OpenType font.
 2IFont font = FontFactory.Open("arial.ttf");
 3
 4// Get the encoder.
 5var encoder = TextUtilsFactory.GetFontMorseEncoder();
 6
 7// Encode “HELLO WORLD”.
 8IEnumerable<int> glyphIds = encoder.Encode(
 9        "HELLO WORLD",
10        font);
11
12Console.WriteLine(string.Join(", ", glyphIds));

Resultado: una lista de identificadores de glifos enteros que se pueden enviar a canales de dibujo personalizados.

 Codificar y renderizar un PNG

 1double fontSize   = 48;                         // points
 2var spacing       = RenderingUtils.LineSpacingType.Auto;
 3int imgWidth      = 800;
 4int imgHeight     = 200;
 5
 6byte[] pngBytes = encoder.Encode(
 7        "SOS HELP",
 8        font,
 9        fontSize,
10        spacing,
11        imgWidth,
12        imgHeight);
13
14File.WriteAllBytes("morse.png", pngBytes);

El PNG visualiza el código Morse usando el punto (.) y el guión (-) predeterminados. Cambie los parámetros punto/guión por símbolos alternativos ('·', '—', etc.).

 Decodificar de nuevo a texto sin formato

1var decoder = TextUtilsFactory.GetFontMorseDecoder();
2
3string morse   = "... --- ...";   // classic SOS
4string result  = decoder.Decode(morse, font);
5
6Console.WriteLine(result);        // prints: SOS

Cuando se utilizó un alfabeto personalizado durante la codificación, pase el mismo valor “MorseAlphabets” al decodificador.

 Muestra completa de un extremo a otro (consola C#)

 1using System;
 2using System.IO;
 3using Aspose.Font;
 4using Aspose.Font.TextUtils;
 5using Aspose.Font.Rendering;
 6
 7class Program
 8{
 9    static void Main()
10    {
11        // Load a font.
12        IFont font = FontFactory.Open("CourierNew.ttf");
13
14        // Factories.
15        var factory   = TextUtilsFactory.Instance;
16        var encoder   = factory.GetFontMorseEncoder();
17        var decoder   = factory.GetFontMorseDecoder();
18
19        const string message = "CALL ME AT 5PM";
20
21        // Encode → PNG.
22        byte[] png = encoder.Encode(
23            message,
24            font,
25            fontSize: 36,
26            spacing: RenderingUtils.LineSpacingType.Auto,
27            width: 900,
28            height: 150);
29
30        File.WriteAllBytes("callme.png", png);
31        Console.WriteLine("PNG created.");
32
33        // Encode → glyph IDs.
34        var ids = encoder.Encode(message, font);
35        Console.WriteLine("Glyph IDs: " + string.Join(", ", ids));
36
37        // Decode a plain Morse string.
38        string morse   = "... --- ...";
39        string decoded = decoder.Decode(morse, font);
40        Console.WriteLine($"Decoded '{morse}' → {decoded}");
41    }
42}

Ejecútelo en cualquier proyecto .NET Core/.NET Framework; la única dependencia externa es Aspose.Font.

Demostración en línea

Aspose proporciona una demostración web gratuita para probar el traductor sin instalar nada:

Características de la demostración:

Texto ↔︎ Morse ↔︎ Representación de glifos
Elija caracteres personalizados de punto/guión
Descargue PNG generado o vea ID de glifos

Notas de la versión

Aspose.Font para .NET 23.10 API añadidas: TextUtilsFactory, IFontMorseEncoder, IFontMorseDecoder, IMorseEncoder, IMorseDecoder, enumeración MorseAlphabets. Nueva función: “Compatibilidad con codificación de código Morse”.

Cuándo usar qué sobrecarga

Situación	Sobrecarga recomendada
Solo se necesitan identificadores de glifo para el procesamiento posterior	`Encode(string text, IFont font)` (o con alfabeto explícito)
Se desea una imagen sin gestionar el código de renderizado	`Encode(string text, IFont font, double size, LineSpacingType spacing, int w, int h)`
Símbolos de punto/guión personalizados (p. ej., Unicode “·” y “—”)	Usar sobrecargas que acepten `char dot` y `char dash`
El idioma de origen usa una escritura no latina y la detección automática falla	Pasar el valor `MorseAlphabets` apropiado explícitamente

Resumen

Aspose.Font ahora incluye un motor completo de traducción de código Morse que opera tanto en el nivel de glifo como en el nivel de mapa de bits. Utilizando los métodos simples de fábrica, puede comenzar instantáneamente a codificar, decodificar y renderizar cualquier texto en docenas de alfabetos sin escribir sus propias tablas de mapeo ni lidiar con renderizado de bajo nivel.

Ya sea que esté construyendo:

Un componente personalizado de visualización de señales
Una herramienta educativa para enseñar la comunicación Morse.
Un paso de ofuscación de datos que almacena información como fuentes estilizadas

la API le brinda control total mientras mantiene el código limpio, multiplataforma y totalmente compatible.

Usando objetos Glifo ¿Cómo cargar fuentes?