Traduzione in codice Morse con Aspose.Font | .NET

Traduzione in codice Morse con Aspose.Font per.NET

Cos’è la traduzione in codice Morse?

Questa è una funzionalità che ti consente di:

Obiettivo	Come funziona
Codifica il testo normale in glifi in codice Morse di un font (o di un’immagine bitmap)	`IFontMorseEncoder` converte i caratteri in una sequenza di simboli punto (`.`) e trattino (`-`) e li mappa agli identificatori di glifo dell’`IFont` fornito.
Decodifica una stringa che contiene già simboli Morse in testo leggibile	`IFontMorseDecoder` esegue l’operazione inversa.
Renderizza i glifi codificati direttamente in PNG (o in qualsiasi formato raster supportato da Aspose.Font)	Gli overload che accettano parametri di rendering (`LineSpacingType`, dimensione dell’immagine, ecc.) creano l’immagine automaticamente.

La funzionalità è stata introdotta in Aspose.Fontfor.NET23.10 (FONTNET‑602 – Supporto per la codifica del codice Morse).

Perché usarlo?

Soluzione Pure‑C#: nessuna libreria esterna, nessuna dipendenza a livello di sistema operativo.
Funziona con qualsiasi font che contenga i glifi richiesti (TrueType, OpenType, CFF…).
L’euristica incorporata seleziona automaticamente l’alfabeto corretto (latino, greco, cirillico e così via) quando lo ometti.
Sia testo → ID glifi (utile per pipeline di rendering personalizzate) e ID glifi → PNG sono disponibili immediatamente.
Completamente coperto dal supporto di Aspose (forum, documenti, demo live).

Iniziare

1 Installare il pacchetto NuGet

1dotnet add package Aspose.Font

2 Aggiungere spazi dei nomi (C#)

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

Panoramica dell’API

1 Fabbrica – punto di ingresso

Metodo	Restituisce	Descrizione
`TextUtilsFactory.GetFontMorseEncoder()`	`IFontMorseEncoder`	Codificatore che funziona con un’istanza `IFont`
`TextUtilsFactory.GetMorseEncoder()`	`IMorseEncoder`	Codificatore che produce stringhe Morse semplici (senza font)
`TextUtilsFactory.GetFontMorseDecoder()`	`IFontMorseDecoder`	Decodificatore che converte i glifi in testo
`TextUtilsFactory.GetMorseDecoder()`	`IMorseDecoder`	Decodificatore per stringhe Morse semplici

La fabbrica si trova in Aspose.Font.Factories.TextUtilsFactory (aggiunto nel 23.10).

2 interfacce principali

“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}

“IFontMorseDecoder”.

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`.

Funzionano solo con stringhe grezze (nessun carattere coinvolto). Usali quando hai solo bisogno di sequenze “punto-linea”.

3 Enumerazione di supporto – “Alfabeti Morse”.

Valore	Script
`Latino`	Inglese e la maggior parte delle lingue occidentali
`Greco`	Lettere greche
`Cirillico`	Russo, bulgaro, ecc.
`Ebraico`	Lettere ebraiche
`Arabo`	Scrittura araba
`Portoghese`	Simboli specifici del portoghese
`Curdo`	Lettere curde
`Persiano`	Lettere persiane/farsi

Se ometti l’enumerazione, il codificatore tenta il rilevamento automatico.

Esempi pratici

 Codifica in ID glifi

 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));

Risultato: un elenco di identificatori di glifi interi che possono essere inseriti nelle pipeline di disegno personalizzate.

 Codifica e renderizza 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);

Il PNG visualizza il codice Morse utilizzando il punto (.) e il trattino (-) predefiniti. Modifica i parametri punto/trattino per simboli alternativi ('·', '—', ecc.).

 Decodifica in testo normale

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

Quando durante la codifica è stato utilizzato un alfabeto personalizzato, passa lo stesso valore “MorseAlphabets” al decodificatore.

 Esempio end-to-end completo (console 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}

Eseguilo su qualsiasi progetto .NET Core/.NET Framework: l’unica dipendenza esterna è Aspose.Font.

Dimostrazione in linea

Aspose fornisce una demo web gratuita per provare il traduttore senza installare nulla:

Caratteristiche della demo:

Testo ↔︎ Morse ↔︎ Rendering glifi
Scegli caratteri punto/trattino personalizzati
Scarica il PNG generato o visualizza gli ID dei glifi

Note sulla versione

Aspose.Font for .NET 23.10
Added APIs: TextUtilsFactory, IFontMorseEncoder, IFontMorseDecoder, IMorseEncoder, IMorseDecoder, enumeration MorseAlphabets.
New Feature: “Support for Morse code encoding”.

Quando utilizzare quale sovraccarico

Situazione	Sovraccarico consigliato
Sono necessari solo identificatori di glifi per l’ulteriore elaborazione	`Encode(string text, IFont font)` (o con alfabeto esplicito)
Si desidera un’immagine senza gestire il codice di rendering	`Encode(string text, IFont font, double size, LineSpacingType spacing, int w, int h)`
Simboli punto/trattino personalizzati (ad esempio, Unicode “·” e “—”)	Utilizza overload che accettano `char dot` e `char dash`
La lingua di origine utilizza un alfabeto non latino e il rilevamento automatico fallisce	Passa esplicitamente il valore `MorseAlphabets` appropriato

Riepilogo

Aspose.Font ora include un motore completo di traduzione del codice Morse che opera sia a livello di glifi che a livello di bitmap. Utilizzando i semplici metodi di fabbrica puoi iniziare immediatamente a codificare, decodificare e rendere qualsiasi testo in dozzine di alfabeti senza scrivere le tue tabelle di mappatura o occuparti del rendering di basso livello.

Sia che tu stia costruendo:

Un componente personalizzato per la visualizzazione del segnale
Uno strumento educativo per insegnare la comunicazione Morse
Una fase di offuscamento dei dati che memorizza le informazioni come caratteri stilizzati

l’API ti offre il pieno controllo mantenendo il codice pulito, multipiattaforma e completamente supportato.

Utilizzo di oggetti Glyph Come caricare i caratteri?