Morse‑Code Translation with Aspose.Font | .NET

Morse‑Code Translation with Aspose.Font for .NET

What is Morse‑Code translation?

This is functionality that lets you:

Goal	How it works
Encode plain‑text into Morse‑code glyphs of a font (or a bitmap image)	IFontMorseEncoder converts characters to a sequence of dot (.) and dash (-) symbols and maps them to glyph identifiers of the supplied IFont.
Decode a string that already contains Morse symbols back into readable text	IMorseDecoder returns plain text; IFontMorseDecoder returns glyph identifiers or a PNG stream using a supplied font.
Render text as Morse code in PNG format	Rendering overloads accept a font, font size, line spacing, and maximum width, and return a PNG stream.

The feature was introduced in Aspose.Font for .NET 23.10 (FONTNET‑602 – Support for Morse code encoding).

Why use it?

• Pure‑C# solution – no external libraries, no OS‑level dependencies.
• Works with any font that contains the required glyphs (TrueType, OpenType, CFF …).
• Built‑in heuristics automatically pick the correct alphabet (Latin, Greek, Cyrillic, etc.) when you omit it.
• Both text → glyph IDs (useful for custom rendering pipelines) and text → Morse PNG are available out‑of‑the‑box.
• Fully covered by Aspose’s support (forums, docs, live demo).

Getting started

1 Install the NuGet package

dotnet add package Aspose.Font

2 Add namespaces (C#)

using System;
using System.IO;
using System.Linq;
using Aspose.Font;
using Aspose.Font.Factories;
using Aspose.Font.Glyphs;
using Aspose.Font.Renderers;
using Aspose.Font.Sources;
using Aspose.Font.TextUtils;

API overview

1 Factory – entry point

Create a TextUtilsFactory instance with new TextUtilsFactory(), then call its instance methods:

Method	Returns	Description
GetFontMorseEncoder()	IFontMorseEncoder	Encodes text as glyph identifiers or a PNG stream using a supplied font
GetMorseEncoder()	IMorseEncoder	Encodes text as a plain Morse string without a font
GetFontMorseDecoder()	IFontMorseDecoder	Decodes Morse into glyph identifiers or a PNG stream using a supplied font
GetMorseDecoder()	IMorseDecoder	Decodes a Morse string to plain text without a font

The factory lives in Aspose.Font.Factories.TextUtilsFactory (added in 23.10).

2 Core interfaces

IFontMorseEncoder

The glyph overloads return GlyphId[]. The rendering overloads return a PNG Stream, which the caller should dispose after copying or consuming it.

Result	Parameters
GlyphId[]	Text and an IFont, with either automatic alphabet detection or an explicit MorseAlphabets value
PNG Stream	Text, an IFont, fontSize, RenderingUtils.LineSpacingType, lineSpacingValue, and maxWidth, with an optional explicit alphabet overload

LineSpacingType supports Pixels and PercentOfFontHeight. The renderer calculates the image height; there is no fixed-height parameter.

The optional inputSeparator and outputSeparator characters delimit words. For encoding, their defaults are a space and /, respectively. They do not replace the Morse dot and dash symbols.

IFontMorseDecoder

IFontMorseDecoder accepts a Morse string, a font, and an explicit MorseAlphabets value. It returns either GlyphId[] for the decoded text or a PNG Stream when rendering parameters are supplied. It does not return plain text.

Use IMorseDecoder to obtain a decoded string without loading a font. For decoding, inputSeparator defaults to / and outputSeparator defaults to a space.

IMorseEncoder / IMorseDecoder

These work with raw strings only (no font involved). Use them when you only need “dot‑dash” sequences.

3 Supporting enum – MorseAlphabets

Value	Script
Latin	English & most Western languages
Greek	Greek letters
Cyrillic	Russian, Bulgarian, etc.
Hebrew	Hebrew letters
Arabic	Arabic script
Portuguese	Portuguese specific symbols
Kurdish	Kurdish letters
Persian	Persian / Farsi letters

If you omit the enum, the encoder attempts automatic detection.

Practical examples

The font-based examples use TTF/LatoWeb-Regular.ttf. Set DataDir to the directory containing the TTF folder and OutputDir to an existing output directory. Plain-text decoding does not require a font.

1.  Encode to glyph IDs

// Encode text as Morse-code glyph identifiers

// Load a font containing the Morse-code symbols.
string fontPath = Path.Combine(DataDir, "TTF", "LatoWeb-Regular.ttf");
Font font = Font.Open(new FontDefinition(
    FontType.TTF, "ttf", new FileSystemStreamSource(fontPath)));

// Create the factory and get the font encoder.
var factory = new TextUtilsFactory();
IFontMorseEncoder encoder = factory.GetFontMorseEncoder();

// Encode HELLO WORLD using automatic alphabet detection.
GlyphId[] glyphIds = encoder.Encode("HELLO WORLD", font);
Console.WriteLine(string.Join(", ", glyphIds.Select(id => id.ToString())));

Result: An array of GlyphId objects representing the Morse symbols, suitable for custom drawing pipelines.

2.  Encode and render a PNG

This fragment reuses the font and encoder from the preceding example. It saves morse.png in OutputDir.

// Encode text as Morse code and save a PNG

double fontSize = 48;
var spacing = RenderingUtils.LineSpacingType.Pixels;
int lineSpacing = 10;
int maxWidth = 800;

// The renderer returns a stream and determines the image height.
using (Stream pngStream = encoder.Encode(
    "SOS HELP", font, fontSize, spacing, lineSpacing, maxWidth))
{
    if (pngStream.CanSeek)
        pngStream.Position = 0;

    using (FileStream output = File.Create(Path.Combine(OutputDir, "morse.png")))
    {
        pngStream.CopyTo(output);
    }
}

The PNG visualises Morse code using dot (.) and dash (-) glyphs from the font. The character parameters control word separators, not alternative dot/dash symbols.

3.  Decode back to plain text

// Decode a Morse-code string to plain text

// Plain-text decoding does not require a font.
IMorseDecoder decoder = new TextUtilsFactory().GetMorseDecoder();
string morse = "... --- ...";
string result = decoder.Decode(morse, MorseAlphabets.Latin);
Console.WriteLine(result); // SOS

When a custom alphabet was used during encoding, pass the same MorseAlphabets value to the decoder.

4.  Combined example (C#)

// Render Morse code, obtain glyph identifiers and decode a message

// Load a font.
string fontPath = Path.Combine(DataDir, "TTF", "LatoWeb-Regular.ttf");
Font font = Font.Open(new FontDefinition(
    FontType.TTF, "ttf", new FileSystemStreamSource(fontPath)));

var factory = new TextUtilsFactory();
IFontMorseEncoder encoder = factory.GetFontMorseEncoder();
IMorseDecoder decoder = factory.GetMorseDecoder();
const string message = "CALL ME AT 5PM";

// Encode to PNG. Height is calculated by the renderer.
using (Stream pngStream = encoder.Encode(
    message, font,
    fontSize: 36,
    lineSpacingType: RenderingUtils.LineSpacingType.Pixels,
    lineSpacingValue: 10,
    maxWidth: 900))
{
    if (pngStream.CanSeek)
        pngStream.Position = 0;

    using (FileStream output = File.Create(Path.Combine(OutputDir, "callme.png")))
    {
        pngStream.CopyTo(output);
    }
}
Console.WriteLine("PNG created.");

// Encode to glyph identifiers.
GlyphId[] ids = encoder.Encode(message, font);
Console.WriteLine("Glyph IDs: " + string.Join(", ", ids.Select(id => id.ToString())));

// Decode a plain Morse string.
string morse = "... --- ...";
string decoded = decoder.Decode(morse, MorseAlphabets.Latin);
Console.WriteLine($"Decoded '{morse}' -> {decoded}");

The combined example saves callme.png in OutputDir, prints the encoded glyph identifiers, and decodes ... --- ... to SOS. Use the namespaces and directory setup shown above.

Online demo

Aspose provides a free web demo to try the translator without installing anything:

Features of the demo:

• Text ↔︎ Morse ↔︎ Glyph rendering
• Choose custom dot/dash characters
• Download generated PNG or view glyph IDs

Release notes

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

When to use which overload

Situation	Recommended overload
Need only glyph identifiers for further processing	Encode(string text, IFont font) (or with explicit alphabet)
Want a PNG stream without handling rendering code	Use the overload with fontSize, lineSpacingType, lineSpacingValue, and maxWidth
Custom word separators	Set inputSeparator and outputSeparator; these parameters do not change dot/dash symbols
Source language uses a non‑Latin script and auto‑detect fails	Pass the appropriate MorseAlphabets value explicitly

Summary

Aspose.Font now includes a complete Morse‑code translation engine that operates at both the glyph level and the bitmap level. Using the simple factory methods you can instantly start encoding, decoding, and rendering text in the supported alphabets without writing your own mapping tables or dealing with low‑level rendering.

Whether you are building:

• A custom signal‑visualisation component
• An educational tool to teach Morse communication
• A data‑obfuscation step that stores information as stylised fonts

the API gives you full control while keeping the code clean, cross‑platform, and fully supported.