Converting Text to Image

WPF (Windows Presentation Foundation)is not just a technique to create UIs. You can create any type of vector-based graphics composition and save it to a graphics file.

Here is a simple example that takes any text and font, and renders it into a PNG file:

function Convert-TextToImage
{
  param
  (
    [String]
    [Parameter(Mandatory)]
    $Text,
    
    [String]
    $Font = 'Consolas',
    
    [ValidateRange(5,400)]
    [Int]
    $FontSize = 24,
    
    [System.Windows.Media.Brush]
    $Foreground = [System.Windows.Media.Brushes]::Black,
    
    [System.Windows.Media.Brush]
    $Background = [System.Windows.Media.Brushes]::White
  )
  
  $filename = "$env:temp$(Get-Random).png"

  # take a simple XAML template with some text  
  $xaml = @"
$Text
"@

  Add-Type -AssemblyName PresentationFramework
  
  # turn it into a UIElement
  $reader = [XML.XMLReader]::Create([IO.StringReader]$XAML)
  $result = [Windows.Markup.XAMLReader]::Load($reader)
  
  # refine its properties
  $result.FontFamily = $Font
  $result.FontSize = $FontSize
  $result.Foreground = $Foreground
  $result.Background = $Background
  
  # render it in memory to the desired size
  $result.Measure([System.Windows.Size]::new([Double]::PositiveInfinity, [Double]::PositiveInfinity))
  $result.Arrange([System.Windows.Rect]::new($result.DesiredSize))
  $result.UpdateLayout()
  
  # write it to a bitmap and save it as PNG
  $render = [System.Windows.Media.Imaging.RenderTargetBitmap]::new($result.ActualWidth, $result.ActualHeight, 96, 96, [System.Windows.Media.PixelFormats]::Default)
  $render.Render($result)
  Start-Sleep -Seconds 1
  $encoder = [System.Windows.Media.Imaging.PngBitmapEncoder]::new()
  $encoder.Frames.Add([System.Windows.Media.Imaging.BitmapFrame]::Create($render))
  $filestream = [System.IO.FileStream]::new($filename, [System.IO.FileMode]::Create)
  $encoder.Save($filestream)
  
  # clean up
  $reader.Close() 
  $reader.Dispose()
  
  $filestream.Close()
  $filestream.Dispose()
  
  # return the file name for the generated image
  $filename 
}

Here is how to use:

 
PS> $file = Convert-TextToImage -Text 'Red Alert!' -Font Stencil -FontSize 60 -Foreground Red -Background Gray

PS> Invoke-Item -Path $file
 

Your learning points:

  • With XAML, an XML-based UI description language, you can define graphics
  • PowerShell can use the [Windows.Markup.XAMLReader] class to easily convert any valid XAML into a UIElement object.
  • UIElement objects can be saved as graphics file, for example as a PNG image, can be displayed as a window, or printed. In this example, we focused on saving to file, and we used a very simple XAML definition. Maybe you got curious now. Google for any of the methods used in this example, and you find plenty of reading.

psconf.eu – PowerShell Conference EU 2019 – June 4-7, Hannover Germany – visit www.psconf.eu There aren’t too many trainings around for experienced PowerShell scripters where you really still learn something new. But there’s one place you don’t want to miss: PowerShell Conference EU – with 40 renown international speakers including PowerShell team members and MVPs, plus 350 professional and creative PowerShell scripters. Registration is open at www.psconf.eu, and the full 3-track 4-days agenda becomes available soon. Once a year it’s just a smart move to come together, update know-how, learn about security and mitigations, and bring home fresh ideas and authoritative guidance. We’d sure love to see and hear from you!

Twitter This Tip! ReTweet this Tip!

v

Converting IEEE754 (Float) (Part 2)

Yesterday we looked at how PowerShell can turn IEEE754 floating point values returned by a sensor into the actual value. This involved reversing the byte order and using the BitConverter class.

If you have received a IEEE754 value in hex format, like 0x3FA8FE3B, the first task is to split the hex value into four bytes. There is a surprisingly easy way to do this: treat the hex value as an IPv4 address. These addresses internally use four bytes as well.

Here is a quick and simple approach to turn the sensor hex value into a useful numeric value:

$hexInput = 0x3FA8FE3B

$bytes = ([Net.IPAddress]$hexInput).GetAddressBytes()
$numericValue = [BitConverter]::ToSingle($bytes, 0)

"Sensor: $numericValue"

Your learning points:


  • Convert numbers to an IPAddress object to split the number into bytes. This approach can also be used to get the Least Significant Byte (LSB)or Most Significant Byte (MSB)from a number


psconf.eu – PowerShell Conference EU 2019 – June 4-7, Hannover Germany – visit www.psconf.eu There aren’t too many trainings around for experienced PowerShell scripters where you really still learn something new. But there’s one place you don’t want to miss: PowerShell Conference EU – with 40 renown international speakers including PowerShell team members and MVPs, plus 350 professional and creative PowerShell scripters. Registration is open at www.psconf.eu, and the full 3-track 4-days agenda becomes available soon. Once a year it’s just a smart move to come together, update know-how, learn about security and mitigations, and bring home fresh ideas and authoritative guidance. We’d sure love to see and hear from you!

Twitter This Tip! ReTweet this Tip!

Converting IEEE754 (Float) (Part 1)

PowerShell is extremely versatile and nowadays often used with IoT and sensors as well. Some return values in IEEE754 float format which typically is a series of four hexadecimal bytes.

Let’s assume a sensor returns a value in the hexadecimal format of 3FA8FE3B and uses IEEE754 formatting. How do you get the real value?

Technically, you have to reverse the byte order, then use the BitConverter to produce a “Single” value.

Take 3FA8FE3B, split it into pairs, reverse the order, then convert to a number:

$bytes = 0x3B, 0xFE, 0xA8, 0x3F
[BitConverter]::ToSingle($bytes, 0)

As it turns out, the hex value 0x3FA8FE3B returns the sensor value 1.320258. Today, we focused on the BitConverter class that provides methods to convert byte arrays to numeric values. Tomorrow, we look at the other part: splitting text hex values into pairs and reversing the order.

Learning points for today:

  • Use [BitConverter] to convert raw bytes and byte arrays into other numeric formats. The class comes with a multitude of methods:
 
PS> [BitConverter] | Get-Member -Static | Select-Object -ExpandProperty Name

DoubleToInt64Bits
Equals
GetBytes
Int64BitsToDouble
IsLittleEndian
ReferenceEquals
ToBoolean
ToChar
ToDouble
ToInt16
ToInt32
ToInt64
ToSingle
ToString
ToUInt16
ToUInt32
ToUInt64 
 

To see the syntax for any of these methods, enter them without parenthesis:

 
PS> [BitConverter]::ToUInt32

OverloadDefinitions                                   
-------------------                                   
static uint32 ToUInt32(byte[] value, int startIndex)  
 

psconf.eu – PowerShell Conference EU 2019 – June 4-7, Hannover Germany – visit www.psconf.eu There aren’t too many trainings around for experienced PowerShell scripters where you really still learn something new. But there’s one place you don’t want to miss: PowerShell Conference EU – with 40 renown international speakers including PowerShell team members and MVPs, plus 350 professional and creative PowerShell scripters. Registration is open at www.psconf.eu, and the full 3-track 4-days agenda becomes available soon. Once a year it’s just a smart move to come together, update know-how, learn about security and mitigations, and bring home fresh ideas and authoritative guidance. We’d sure love to see and hear from you!

Twitter This Tip! ReTweet this Tip!

Be Careful With “Throw” Statements (Part 2)

In the previous tip we explained how the throw statement can be influenced by $ErrorActionPreference set to “SilentlyContinue”, and that throw will not exit function code properly. Here is again the example we used:

function Copy-Log
{
  "Doing prerequisites"
  "Testing whether target path exists"
  "If target path does not exist, bail out"
  throw "Target path does not exist"
  "Copy log files to target path"
  "Delete log files in original location"
}
 
PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
Target path does not exist
In Zeile:8 Zeichen:3
+   throw "Target path does not exist"
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (Target path does not exist:String) [], RuntimeExceptio 
   n
    + FullyQualifiedErrorId : Target path does not exist


PS> $ErrorActionPreference = 'SilentlyContinue'

PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
Copy log files to target path
Delete log files in original location
 

While throw exists the function with the default ErrorAction, it continues the code when ErrorAction is set to “SilentlyContinue”. This most likely is a bug because the only difference between the ErrorAction settings “Continue” and “SilentlyContinue” should be whether error messages are visible or not. These settings should not affect the code that is actually executed.

The bug in throw only occurs when the terminating error emitted by throw is not handled. Once you use try…catch or even add a simple (and completely empty) trap statement, all is fine, and throw works as expected:

# add a trap to fix
trap {}

$ErrorActionPreference = "SilentlyContinue"
Copy-Log
$ErrorActionPreference = "Continue"
Copy-Log 

Once the trap is in place, the code will exit at the throw statement regardless of $ErrorActionPreference setting. You might want to add the empty trap statement to your PowerShell profile script to be protected from this bug, or reconsider the use of throw altogether.

Your learning points:

  • Throw is part of an error handling system, and the exception emitted by throw needs to be caught by try…catch or trap. If the exception is not caught, throw may not work as expected.
  • Because of this, try not to use throw to exit function code for functions that are exposed to end users. For end users, rather than emitting an (ugly) exception, emit a human-friendly error message using Write-Warning or Write-Host, and exit the code using the “return” statement
  • If you must emit an exception so that callers can catch it in their error handlers, but also want to make sure your code definitely exists regardless of $ErrorActionPreference, use Write-Error in combination with the “return” statement:
function Copy-Log
{
  "Doing prerequisites"
  "Testing whether target path exists"
  "If target path does not exist, bail out"
  Write-Error "Target path does not exist"; return
  "Copy log files to target path"
  "Delete log files in original location"
}

Since “return” is not affected by the $ErrorActionPreference, your code will always exit. Let’s test:

 
PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
Copy-Log : Target path does not exist
In Zeile:1 Zeichen:1
+ Copy-Log
+ ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Copy-Log  
 

With $ErrorActionPreference set to SilentlyContinue, the error message is suppressed as expected, but the code will reliably exit:

 
PS> $ErrorActionPreference = 'SilentlyContinue'

PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
 

psconf.eu – PowerShell Conference EU 2019 – June 4-7, Hannover Germany – visit www.psconf.eu There aren’t too many trainings around for experienced PowerShell scripters where you really still learn something new. But there’s one place you don’t want to miss: PowerShell Conference EU – with 40 renown international speakers including PowerShell team members and MVPs, plus 350 professional and creative PowerShell scripters. Registration is open at www.psconf.eu, and the full 3-track 4-days agenda becomes available soon. Once a year it’s just a smart move to come together, update know-how, learn about security and mitigations, and bring home fresh ideas and authoritative guidance. We’d sure love to see and hear from you!

Twitter This Tip! ReTweet this Tip!

Be Careful With “Throw” Statements (Part 1)

Throw is a PowerShell statement that emits an exception to the caller and then exits the code. At least in theory. In the real world, throw might not exit the code, and the results can be devastating.

To understand the problem, take a look at this demo function:

function Copy-Log
{
  "Doing prerequisites"
  "Testing whether target path exists"
  "If target path does not exist, bail out"
  throw "Target path does not exist"
  "Copy log files to target path"
  "Delete log files in original location"
}

When you run Copy-Log, it simulates a fail, assuming a hypothetical target path does not exist. When the target path is not present, log files cannot be copied. When log files cannot be copied, they should not be deleted. That’s why the code needs to exit when throw is called. And it does:

 
PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
Target path does not exist
In Zeile:8 Zeichen:3
+   throw "Target path does not exist"
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (Target path does not exist:String) [], RuntimeExceptio 
   n
    + FullyQualifiedErrorId : Target path does not exist

PS> 
 

However, this is based on the default $ErrorActionPreference value of “Continue”. When a user happens to change this to “SilentlyContinue” in order to suppress error messages, throw suddenly gets completely ignored, and all code executes:

 
PS> $ErrorActionPreference = 'SilentlyContinue'

PS> Copy-Log
Doing prerequisites
Testing whether target path exists
If target path does not exist, bail out
Copy log files to target path
Delete log files in original location
 

In this scenario, you would have lost all log files because the copy process did not work, yet the code continued and deleted the original files.

Important learning point:

  • If it is important for you to exit a function, throw may not really exit the function. You might want to use a different method to exit your code, for example the “return” statement.

psconf.eu – PowerShell Conference EU 2019 – June 4-7, Hannover Germany – visit www.psconf.eu There aren’t too many trainings around for experienced PowerShell scripters where you really still learn something new. But there’s one place you don’t want to miss: PowerShell Conference EU – with 40 renown international speakers including PowerShell team members and MVPs, plus 350 professional and creative PowerShell scripters. Registration is open at www.psconf.eu, and the full 3-track 4-days agenda becomes available soon. Once a year it’s just a smart move to come together, update know-how, learn about security and mitigations, and bring home fresh ideas and authoritative guidance. We’d sure love to see and hear from you!

Twitter This Tip! ReTweet this Tip!