john.geek.nz - 38911 Basic Bytes Free » C# Tips

C# equivalent to VB val() function

John Burns — Thu, 13 Aug 2009 19:35:12 +0000

Although VB had it’s limitations, it was damn easy to filter an input string for a numerical value.

Here is how to do it in C#. You’ll need to use System.Text.RegularExpressions in the header

private static int VBVal(string sInput)
{
        string sOutput = string.Empty;
        MatchCollection oMatches = Regex.Matches(sInput, "\\d+");
        foreach (Match oMatch in oMatches)
        {
                sOutput += oMatch.ToString();
        }
        return (int)sOutput;
}

Image Editing in C# – Contrast

John Burns — Fri, 27 Mar 2009 16:25:35 +0000

When attempting to get machines to process images you sometimes run into noise problems. Filters are regularly applied first to clean them up.

Editing the contrast of an image changes its dynamic range. In its most basic form, it will move pixel values away from the center (normally 128 if using 8 bits per color).

There are many different ways to to perform contrast adjustment.

The basic process is:

For each pixel in the image…
Divide each of the red, green and blue values by 255 to get a decimal value between 0 and 1
Subtract 0.5 from each of these values to get a delta from average
Multiply each of these value by a contrast ratio
Add 0.5 back to each value
Multiply each value by 255
Change any values less than 0 to 0
Change any values greater than 255 to 255

The contrast ratio is sometimes calculated from a RMS of the entire image contrast.
In this simple (but effective) case:

Take a contrast adjustment value between -100 and 100
Add 100 to the value and divide by 100 (To get a value between 0 and 2)
Square this result (Now between 0 and 4)

An input contrast adjustment value of 10 will result in a contrast ratio of (110/100)^2 = 1.21 and the following results:
0,0,0 – > 0,0,0
64,64,64 -> 51,51,51
128,128,128 – > 128,128,128
192,192,192 -> 208,208,208
255,255,255 -> 255,255,255

As you can see, the darkest, brightest and middle shades are retained, everything else is exponentially pushed towards one of the two extremes.

Here is some C# code to perform the steps above. It takes a Bitmap type and a byte value between -100 and 100.

public static Bitmap Contrast(Bitmap oBitmap, sbyte iContrast)
{
    if (iContrast < -100) return oBitmap;
    if (iContrast > 100) return oBitmap;
 
    double pixel = 0;
    //convert contrast to a decimal value
    double contrast = (100.0 + iContrast) / 100.0;
 
    contrast *= contrast;
 
    BitmapData bmData = oBitmap.LockBits(new Rectangle(0, 0, oBitmap.Width, oBitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
 
    int stride = bmData.Stride;
    System.IntPtr Scan0 = bmData.Scan0;
 
    unsafe
    {
        byte* p = (byte*)(void*)Scan0;
 
        int iRowEnd = stride - oBitmap.Width * 3;
 
        for (int y = 0; y < oBitmap.Height; ++y)
        {
            for (int x = 0; x < oBitmap.Width; ++x)
            {
                for (int color = 0; color < 3; color++)
                //0 = Blue, 1 = Green, 2 = Red
                {
 
                    pixel = p[color] / 255.0;
                    pixel -= 0.5;
                    pixel *= contrast;
                    pixel += 0.5;
                    pixel *= 255;
                    if (pixel < 0) pixel = 0;
                    if (pixel > 255) pixel = 255;
                    p[color] = (byte)pixel;
                }
                p += 3;
            }
            p += iRowEnd;
        }
    }
 
    oBitmap.UnlockBits(bmData);
 
    return oBitmap;
}

Image Editing in C# – Greyscale

John Burns — Mon, 23 Mar 2009 15:33:04 +0000

I’m in the process of writing some code to detect the stars in astromical images. One of the filters I need to apply to an image is to convert it to greyscale.

Conversion to greyscale is relatively straightforward – The red, green and blue values of a pixel all need to be set to the same value.

There is one caveat, and that is that our eyes are sensitive to different colors. This means that color images tend to have lots of blue and red when compared to green.

A typical formula to use is:
whitevalue = (red * .30) + (green * .59) + (blue * .11)

Note that in the above formula, the three decimal values add to 1.00. This means that white in the image is preserved and the range of 0-255 is not exceeded.

Here is some C# code to convert an image to greyscale. It takes a Bitmap type and returns a Bitmap type. It uses unsafe code for speed so you will need to compile with the allow unsafe code option.

public class imageFilters
{
    public static Bitmap greyScale(Bitmap oBitmap)
    {
        BitmapData bmData = oBitmap.LockBits(new Rectangle(0, 0, oBitmap.Width,
            oBitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
 
        int stride = bmData.Stride;
        System.IntPtr Scan0 = bmData.Scan0;
 
        unsafe
        {
            byte* ptr = (byte*)(void*)Scan0;
 
            int iRowEnd = stride - (oBitmap.Width * 3);
 
            for (int y = 0; y < oBitmap.Height; ++y)
            {
                for (int x = 0; x < oBitmap.Width; ++x)
                {
                    //GDI returns BGR rather than RGB
                    //Hence ptr[0] is Blue NOT Red
                    ptr[0] = ptr[1] = ptr[2] =
                        (byte)((.30 * ptr[2]) + (.59 * ptr[1]) + (.11 * ptr[0]));
 
                    ptr += 3;
                }
                ptr += iRowEnd;
            }
        }
 
        oBitmap.UnlockBits(bmData);
        return oBitmap;
    }

Enjoy….

TLEs – Calculation of the Julian Day Number (JDN)

John Burns — Fri, 13 Mar 2009 02:28:44 +0000

This post is part of a series on understanding the meaning behind the values contained in a Two Line Element set, or Keplerian Elements. The main article is here.

Calculation of the Julian Day Number (JDN)

Julian day numbers are regularly used in astronomy instead of a date.

Julian day numbers are simply the count of days that have elapse since noon on January 1, 4713 BC Greenwich time using the Julian proleptic calendar.

We generally use the Gregorian calendar. Calculation to a Julian date is a little cryptic as the two calendars have different rules for calculating leap years.

Every 4 years

Every 4 years except when the year is divisble by 100
But ALWAYS every 400 years

To calculate the value, we first get the Julian date of the year, then add on the days in the year followed by the fraction of the day.

Some astronomers like to use a Modified Julian Date. This is simply the Julian Date with 2,400,000.5 subtracted from it making the number smaller and based on midnight rather than noon UTC.

Here is some C# which will calculate the following:

Julian Day from a DateTime
Julian Day for a year
Julian Day from a Satellite Epoch
Converting between modified and standard Julian dates

double getJulianDay_DateTime(DateTime date)
{
    //Calculate the day of the year and the
    double dDay = date.DayOfYear;
    dDay += Convert.ToDouble(date.Hour) / 24;
    dDay += Convert.ToDouble(date.Minute) / 1440;
    dDay += Convert.ToDouble(date.Second) / 86400;
 
    return dDay + getJulianDay_Year(date.Year);
}
 
double getJulianDay_Year(int year)
{
    double dYear = year - 1;
    double A = Math.Floor(dYear / 100);
    double B = 2 - A + Math.Floor(A / 4);
    //The use of 30.600000000000001 is to correct for floating point rounding problems
    double dResult = Math.Floor(365.25 * dYear) + 1721422.9 + B;
    return dResult;
}
 
double getJulianDay_SatEpoch(int year, double dSatelliteEpoch)
{
    //Tidy up the year and put it into the correct century
    year = year % 100;
    if (year < 57) year += 2000;
    else year += 1900;
 
    double dResult = getJulianDay_Year(year);
    dResult += dSatelliteEpoch;
 
    return dResult;
}
 
double getModifiedJulian_Julian(double dJulian)
{
    return dJulian - 2400000.5;
}
 
double getJulian_ModifiedJulian(double dModifiedJulian)
{
    return dModifiedJulian + 2400000.5;
}

Code: Shortest distance between any two line segments

John Burns — Tue, 10 Mar 2009 10:47:45 +0000

I recently needed to find the shortest distance between any two line segments in 3D space.

I managed to find some C++ code online at http://softsurfer.com/Archive/algorithm_0106/algorithm_0106.htm which I converted to C#.

It’s fairly easy to use. If you only need it for 2D space, just set the Z values to 0.

Please post a comment if you find this useful.

Here is the code:

/*
* Converted to C# by John Burns from C++ sourced from:
* http://softsurfer.com/Archive/algorithm_0106/algorithm_0106.htm
*
* Original C++ Copyright Notice
* ===================
* Copyright 2001, softSurfer (www.softsurfer.com)
* This code may be freely used and modified for any purpose
* providing that this copyright notice is included with it.
* SoftSurfer makes no warranty for this code, and cannot be held
* liable for any real or imagined damage resulting from its use.
* Users of this code must verify correctness for their application.
*/
 
class point
{
    public double x;
    public double y;
    public double z;
}
 
class line
{
    public double x1;
    public double y1;
    public double z1;
    public double x2;
    public double y2;
    public double z2;
}
 
double getShortestDistance(line line1, line line2)
{
    double EPS = 0.00000001;
 
    point delta21 = new point();
    delta21.x = line1.x2 - line1.x1;
    delta21.y = line1.y2 - line1.y1;
    delta21.x = line1.z2 - line1.z1;
 
    point delta41 = new point();
    delta41.x = line2.x2 - line2.x1;
    delta41.y = line2.y2 - line2.y1;
    delta41.z = line2.z2 - line2.z1;
 
    point delta13 = new point();
    delta13.x = line1.x1 - line2.x1;
    delta13.y = line1.y1 - line2.y1;
    delta13.z = line1.z1 - line2.z1;
 
    double a = dot(delta21, delta21);
    double b = dot(delta21, delta41);
    double c = dot(delta41, delta41);
    double d = dot(delta21, delta13);
    double e = dot(delta41, delta13);
    double D = a * c - b * b;
 
    double sc, sN, sD = D;
    double tc, tN, tD = D;
 
    if (D < EPS)
    {
        sN = 0.0;
        sD = 1.0;
        tN = e;
        tD = c;
    }
    else
    {
        sN = (b * e - c * d);
        tN = (a * e - b * d);
        if (sN < 0.0)
        {
            sN = 0.0;
            tN = e;
            tD = c;
        }
        else if (sN > sD)
        {
            sN = sD;
            tN = e + b;
            tD = c;
        }
    }
 
    if (tN < 0.0)
    {
        tN = 0.0;
 
        if (-d < 0.0)
            sN = 0.0;
        else if (-d > a)
            sN = sD;
        else
        {
            sN = -d;
            sD = a;
        }
    }
    else if (tN > tD)
    {
        tN = tD;
        if ((-d + b) < 0.0)
            sN = 0;
        else if ((-d + b) > a)
            sN = sD;
        else
        {
            sN = (-d + b);
            sD = a;
        }
    }
 
    if (Math.Abs(sN) < EPS) sc = 0.0;
    else sc = sN / sD;
    if (Math.Abs(tN) < EPS) tc = 0.0;
    else tc = tN / tD;
 
    point dP = new point();
    dP.x = delta13.x + (sc * delta21.x) - (tc * delta41.x);
    dP.y = delta13.y + (sc * delta21.y) - (tc * delta41.y);
    dP.z = delta13.z + (sc * delta21.z) - (tc * delta41.z);
 
    return Math.Sqrt(dot(dP, dP));
}
 
private double dot(point c1, point c2)
{
    return (c1.x * c2.x + c1.y * c2.y + c1.z * c2.z);
}
 
private double norm(point c1)
{
    return Math.Sqrt(dot(c1, c1));
}

SHA256 and higher in SQL Server

John Burns — Thu, 29 Jan 2009 17:59:23 +0000

As part of a new project I’m doing, I needed to use hashes.

A good source of information on hashes is available from wikipedia.

SQL has the built in function HASHBYTES but this only supports up to the SHA128 algorithm and I want to use SHA256.

I created myself a CLR in C#.net and in some moment of feeling generous, decided to share the code.

This code takes a string and returns the hash as a string however it is a simple process to return a binary instead.

Please comment if you find it useful.

To use it, you’ll need to:

Compile the dll or download my precompiled one
Create the assembly in SQL
Create the user defined scalar function

First of all, the (completely undocumented) csharp. There is a link above to download it as a precompiled binary, otherwise fire up Visual Studio and compile the following in a database project.

using System.Collections;
using System.Data.SqlTypes;
using System.Security.Cryptography;
using Microsoft.SqlServer.Server;
using System.Text;
 
 
namespace cryptohashCLR
{
    public sealed class SqlHash
    {
        [SqlFunction(DataAccess = DataAccessKind.None, IsDeterministic = true, IsPrecise = true, Name = "udf_hashBytes", SystemDataAccess = SystemDataAccessKind.None)]
        public static SqlString CLRHash(SqlString hashtype, SqlString input)
        {
            if (input.IsNull || hashtype.IsNull)
            {
                return SqlString.Null;
            }
 
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(input.ToString());
 
            HashAlgorithm oHash;
 
            switch(hashtype.ToString().ToUpper())
            {
                case "MD5":
                    oHash = new MD5CryptoServiceProvider();
                    break;
                case "SHA":
                case "SHA1":
                case "SHA128":
                    oHash = new SHA1Managed();
                    break;
                case "SHA2":
                case "SHA256":
                    oHash = new SHA256Managed();
                    break;
                case "SHA3":
                case "SHA384":
                    oHash = new SHA384Managed();
                    break;
                case "SHA5":
                case "SHA512":
                    oHash = new SHA512Managed();
                    break;
                default:
                    return SqlString.Null;
            }
 
            byte[] hashedBytes = oHash.ComputeHash(plainTextBytes);
 
            string cleanoutput = System.BitConverter.ToString(hashedBytes);
 
            cleanoutput = cleanoutput.Replace("-", "");
 
            return new SqlString(cleanoutput);
 
        }
    }
}

Once you have the dll, here is the SQL to create the assembly. You’ll need to change the path in the script to that of the dll. Once the assembly is created, the dll is no longer required.

/*
--You'll need to run this part if CLR is not enabled on your database
EXEC sp_configure 'clr enabled', 1;
RECONFIGURE WITH OVERRIDE;
GO
*/
 
DECLARE @strDllPath VARCHAR(256)
--Set this path to the path of the dll
SET @strDllPath = 'C:\cryptohashCLR.dll'
 
--Drop the assembly if it already exists
IF EXISTS (SELECT * FROM sys.assemblies asms WHERE asms.name = N'cryptohashCLR')
	DROP ASSEMBLY [cryptohashCLR]
--Create the assembly
CREATE ASSEMBLY [cryptohashCLR] FROM @strDllPath WITH PERMISSION_SET = SAFE

And then finally, you an now create the function.

IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[udf_hashBytes]') AND type in (N'FN', N'IF', N'TF', N'FS', N'FT'))
DROP FUNCTION [dbo].[udf_hashBytes]
GO
 
CREATE FUNCTION [dbo].[udf_hashBytes]
	(
	@hashtype NVARCHAR(MAX),
	@input NVARCHAR(MAX)
	)
RETURNS NVARCHAR(MAX) AS EXTERNAL NAME cryptohashCLR.[cryptohashCLR.SqlHash].CLRHash
GO
 
--Execute sample cases
IF dbo.udf_hashbytes('SHA1','The quick brown fox jumps over the lazy dog') = '2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12'
	PRINT 'Successful: Output of UDF test was as expected'
ELSE
	PRINT 'Error: Inconsistent results were returned from UDF test'

The CLR supports the following hash types:

MD5
SHA128
SHA256
SHA384
SHA512

And is as simple as running:

PRINT dbo.udf_hashbytes('SHA256','INPUT STRING')