Traduction du code Morse avec Aspose.Font | .NET

Traduction du code Morse avec Aspose.Font pour .NET

Qu’est-ce que la traduction en code Morse ?

Il s’agit d’une fonctionnalité qui vous permet :

Objectif	Fonctionnement
Encoder du texte brut en glyphes de code Morse d’une police (ou d’une image bitmap)	`IFontMorseEncoder` convertit les caractères en une séquence de symboles point (`.`) et tiret (`-`) et les associe aux identifiants de glyphes de l’`IFont` fournie.
Décoder une chaîne contenant déjà des symboles Morse pour la reconvertir en texte lisible	`IFontMorseDecoder` effectue l’opération inverse.
Rendre les glyphes encodés directement au format PNG (ou tout autre format raster pris en charge par Aspose.Font)	Les surcharges acceptant des paramètres de rendu (`LineSpacingType`, taille de l’image, etc.) créent l’image automatiquement.

La fonctionnalité a été introduite dans Aspose.Fontfor.NET23.10 (FONTNET‑602 – Prise en charge de l’encodage du code Morse).

Pourquoi l’utiliser ?

Solution Pure‑C# – pas de bibliothèques externes, pas de dépendances au niveau du système d’exploitation.
Fonctionne avec n’importe quelle police contenant les glyphes requis (TrueType, OpenType, CFF…).
L’heuristique intégrée sélectionne automatiquement le alphabet correct (latin, grec, cyrillique, etc.) lorsque vous l’omettez.
texte → ID de glyphe (utiles pour les pipelines de rendu personnalisés) et ID de glyphe → PNG sont disponibles immédiatement.
Entièrement couvert par le support d’Aspose (forums, docs, démo live).

Commencer

1 Installez le package NuGet

1dotnet add package Aspose.Font

2 Ajouter des espaces de noms (C#)

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

Présentation de l’API

1 Usine – point d’entrée

Méthode	Valeur de retour	Description
`TextUtilsFactory.GetFontMorseEncoder()`	`IFontMorseEncoder`	Encodeur fonctionnant avec une instance `IFont`
`TextUtilsFactory.GetMorseEncoder()`	`IMorseEncoder`	Encodeur produisant des chaînes Morse simples (sans police)
`TextUtilsFactory.GetFontMorseDecoder()`	`IFontMorseDecoder`	Décodeur convertissant les glyphes en texte
`TextUtilsFactory.GetMorseDecoder()`	`IMorseDecoder`	Décodeur pour les chaînes Morse simples

L’usine réside dans Aspose.Font.Factories.TextUtilsFactory (ajouté dans 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}

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

Ceux-ci fonctionnent uniquement avec des chaînes brutes (aucune police impliquée). Utilisez-les lorsque vous n’avez besoin que de séquences « points-traits ».

3 Énumération de support – `MorseAlphabets`

Valeur	Script
`Latin`	Anglais et la plupart des langues occidentales
`Greek`	Lettres grecques
`Cyrillic`	Russe, Bulgare, etc.
`Hébreu`	Lettres hébraïques
`Arabe`	Écriture arabe
`Portugais`	Symboles spécifiques au portugais
`Kurde`	Lettres kurdes
`Persan`	Lettres persanes/farsi

Si vous omettez l’énumération, l’encodeur tente une détection automatique.

Exemples pratiques

 Encoder en identifiants de glyphes

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

Résultat : une liste d’identifiants de glyphes entiers qui peuvent être transmis aux pipelines de dessin personnalisés.

 Encoder et restituer 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);

Le PNG visualise le code Morse en utilisant le point (.) et le tiret (-) par défaut. Modifiez les paramètres dot/dash pour les symboles alternatifs ('·', '—', etc.).

 Décoder en texte brut

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

Lorsqu’un alphabet personnalisé a été utilisé lors de l’encodage, transmettez la même valeur « MorseAlphabets » au décodeur.

 Exemple complet de bout en bout (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}

Exécutez-le sur n’importe quel projet .NET Core / .NET Framework – la seule dépendance externe est Aspose.Font.

Démo en ligne

Aspose propose une démo Web gratuite pour essayer le traducteur sans rien installer :

Caractéristiques de la démo :

Texte ↔︎ Morse ↔︎ Rendu des glyphes
Choisissez des caractères point/tiret personnalisés
Téléchargez le PNG généré ou affichez les identifiants des glyphes

Notes de version

Aspose.Font pour .NET 23.10 API ajoutées : TextUtilsFactory, IFontMorseEncoder, IFontMorseDecoder, IMorseEncoder, IMorseDecoder, énumération MorseAlphabets. Nouvelle fonctionnalité : « Prise en charge de l’encodage en code Morse ».

Quand utiliser quelle surcharge

Situation	Surcharge recommandée
Identifiants des glyphes uniquement nécessaires pour la suite du traitement	`Encode(string text, IFont font)` (ou avec un alphabet explicite)
Image sans gestion du rendu	`Encode(string text, IFont font, double size, LineSpacingType spacing, int w, int h)`
Symboles point/tiret personnalisés (ex. : Unicode « · » et « — »)	Utilisez les surcharges acceptant `char dot` et `char dash`
La langue source utilise un alphabet non latin et la détection automatique échoue	Spécifiez explicitement la valeur appropriée de `MorseAlphabets`

Résumé

Aspose.Font inclut désormais un moteur complet de traduction de code Morse qui fonctionne à la fois au niveau glyphe et au niveau bitmap. Grâce aux méthodes simples d’usine, vous pouvez instantanément commencer à encoder, décoder et restituer n’importe quel texte dans des dizaines d’alphabets sans écrire vos propres tables de mappage ni gérer le rendu de bas niveau.

Que vous construisiez :

Un composant personnalisé de visualisation du signal
Un outil pédagogique pour enseigner la communication Morse
Une étape d’obscurcissement des données qui stocke les informations sous forme de polices stylisées

l’API vous donne un contrôle total tout en gardant le code propre, multiplateforme et entièrement pris en charge.

Utiliser des objets Glyphe Comment charger les polices ?