Morsecode-Übersetzung mit Aspose.Font | .NET

Morsecode-Übersetzung mit Aspose.Font für.NET

Was ist Morsecode-Übersetzung?

Mit dieser Funktionalität können Sie:

Ziel	Funktionsweise
Kodieren von Klartext in Morsecode-Glyphen einer Schriftart (oder eines Bitmap-Bildes)	`IFontMorseEncoder` wandelt Zeichen in eine Folge von Punkt (`.`) und Strich (`-`) um und ordnet sie den Glyphen-IDs der angegebenen `IFont` zu.
Dekodieren einer Zeichenkette, die bereits Morsezeichen enthält, zurück in lesbaren Text	`IFontMorseDecoder` führt die umgekehrte Operation durch.
Rendern der kodierten Glyphen direkt als PNG (oder in ein beliebiges von Aspose.Font unterstütztes Rasterformat)	Überladungen, die Rendering-Parameter (`LineSpacingType`, Bildgröße usw.) akzeptieren, erstellen das Bild automatisch.

Die Funktion wurde in Aspose.Fontfor.NET23.10 (FONTNET‑602 – Unterstützung für Morsecode-Kodierung) eingeführt.

Warum es verwenden?

Reine C#-Lösung – keine externen Bibliotheken, keine Abhängigkeiten auf Betriebssystemebene.
Funktioniert mit jeder Schriftart, die die erforderlichen Glyphen enthält (TrueType, OpenType, CFF …).
Integrierte Heuristiken wählen automatisch das richtige Alphabet (Latein, Griechisch, Kyrillisch usw.) aus, wenn Sie es weglassen.
Sowohl Text → Glyphen-IDs (nützlich für benutzerdefinierte Rendering-Pipelines) als auch Glyphen-IDs → PNG sind sofort verfügbar.
Vollständig abgedeckt durch Asposes Support (Foren, Dokumente, Live-Demo).

Erste Schritte

1 Installieren Sie das NuGet-Paket

1dotnet add package Aspose.Font

2 Namespaces hinzufügen (C#)

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

API-Übersicht

1 Fabrik – Einstiegspunkt

Methode	Rückgabewert	Beschreibung
`TextUtilsFactory.GetFontMorseEncoder()`	`IFontMorseEncoder`	Encoder, der mit einer `IFont`-Instanz arbeitet
`TextUtilsFactory.GetMorseEncoder()`	`IMorseEncoder`	Encoder, der einfache Morsezeichenketten erzeugt (ohne Schriftart)
`TextUtilsFactory.GetFontMorseDecoder()`	`IFontMorseDecoder`	Decoder, der Glyphen wieder in Text umwandelt
`TextUtilsFactory.GetMorseDecoder()`	`IMorseDecoder`	Decoder für einfache Morsezeichenketten

Die Fabrik befindet sich in Aspose.Font.Factories.TextUtilsFactory (hinzugefügt in 23.10).

2 Core-Schnittstellen

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

Diese funktionieren nur mit Rohzeichenfolgen (keine Schriftart beteiligt). Verwenden Sie sie, wenn Sie nur „Punkt-Strich“-Sequenzen benötigen.

3 Unterstützende Enumeration – `MorseAlphabets`.

Wert	Schrift
`Latin`	Englisch und die meisten westlichen Sprachen
`Greek`	Griechische Buchstaben
`Cyrillic`	Russisch, Bulgarisch usw.
`Hebrew`	Hebräische Buchstaben
`Arabic`	Arabische Schrift
`Portuguese`	Portugiesische Schriftzeichen
`Kurdish`	Kurdische Buchstaben
`Persian`	Persische/Farsi-Buchstaben

Wenn Sie die Enumeration weglassen, versucht der Encoder eine automatische Erkennung.

Praxisbeispiele

 In Glyphen-IDs kodieren

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

Ergebnis: Eine Liste ganzzahliger Glyphen-IDs, die in benutzerdefinierte Zeichnungspipelines eingespeist werden können.

 Kodieren und rendern Sie ein 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);

Das PNG visualisiert Morsecode mit dem Standardpunkt (.) und dem Bindestrich (-). Ändern Sie die Parameter „Punkt“/„Strich“ für alternative Symbole („·“, „-“ usw.).

 Zurück in Klartext dekodieren

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

Wenn beim Codieren ein benutzerdefiniertes Alphabet verwendet wurde, übergeben Sie denselben „MorseAlphabets“-Wert an den Decoder.

 Vollständiges End-to-End-Beispiel (C#-Konsole)

 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}

Führen Sie es auf einem beliebigen .NET Core-/.NET Framework-Projekt aus – die einzige externe Abhängigkeit ist Aspose.Font.

Online-Demo

Aspose bietet eine kostenlose Web-Demo an, mit der Sie den Übersetzer testen können, ohne etwas zu installieren:

Funktionen der Demo:

Text ↔︎ Morse ↔︎ Glyphendarstellung
Wählen Sie benutzerdefinierte Punkt-/Strichzeichen
Laden Sie generiertes PNG herunter oder zeigen Sie Glyphen-IDs an

Versionshinweise

Aspose.Font für .NET 23.10 Hinzugefügte APIs: TextUtilsFactory, IFontMorseEncoder, IFontMorseDecoder, IMorseEncoder, IMorseDecoder, Enumeration MorseAlphabets. Neue Funktion: „Unterstützung für Morsecode-Codierung“.

Wann welche Überlastung verwendet werden soll

Situation	Empfohlene Überladung
Nur Glyphenbezeichner für die Weiterverarbeitung erforderlich	`Encode(string text, IFont font)` (oder mit explizitem Alphabet)
Bild ohne Rendering-Code gewünscht	`Encode(string text, IFont font, double size, LineSpacingType spacing, int w, int h)`
Benutzerdefinierte Punkt-/Strich-Symbole (z. B. Unicode „·“ & „—“)	Überladungen verwenden, die `char dot` und `char dash` akzeptieren
Quellsprache verwendet nicht-lateinische Schrift und automatische Erkennung schlägt fehl	Den entsprechenden Wert für `MorseAlphabets` explizit angeben

Zusammenfassung

Aspose.Font enthält jetzt eine vollständige Morsecode-Übersetzungs-Engine, die sowohl auf der Glyphenebene als auch auf der Bitmapebene arbeitet. Mit den einfachen Factory-Methoden können Sie sofort mit dem Kodieren, Dekodieren und Rendern von beliebigen Texten in Dutzenden von Alphabeten beginnen, ohne eigene Zuordnungstabellen schreiben oder sich mit Low-Level-Rendering befassen zu müssen.

Ob Sie bauen:

Eine benutzerdefinierte Signalvisualisierungskomponente
Ein Lehrmittel zum Erlernen der Morsekommunikation
Ein Datenverschleierungsschritt, der Informationen als stilisierte Schriftarten speichert

Die API gibt Ihnen die volle Kontrolle und sorgt gleichzeitig dafür, dass der Code sauber, plattformübergreifend und vollständig unterstützt bleibt.

Verwenden von Glyph-ObjektenFont-Bibliothek Wie lade ich Schriftarten?