• Given two line segments p₀p₁ and p₁p₂, if we traverse from p₀ to p₂, did we make a left, right or no turn at p₁?
• Do line segments p₁p₂ and p₃p₄ intersect?

We build on what we learned in Part 1, the cross product.

Download the demo application here

Determining whether consecutive segments turn left or right

Given two line segments p₀p₁ and p₁p₂ we simply check whether the directed segment p₀p₂ is clockwise or counterclockwise relative to directed segment p₀p₁. This is similar to the solution to question 2 in Part 1. If the cross product is negative, then p₀p₂ is counterclockwise to p₀p₁. Hence we should turn left when we reach p₁ to reach p₂ while traversing p₀, p₁ and p₂. If the cross product is 0 (boundary condition) then it means all the three points are collinear (on the same line). The image below shows the three possible scenarios

Using the cross product to determine how p0p1 and p1p2 turn at p1

Determining whether two line segments intersect

Two line segments intersect if and only if either or both of the following conditions are true:

• Each line segment straddles the other line segment.
• An end point of one line segment is on the other line segment

A line segment p₁p₂ straddles another line if p₁ and p₂ are on opposite sides of the line. A boundary condition occurs when one of the end points is on the other line.

Algorithm

Calculate the orientation (using cross product!) d_i for each point of one segment w.r.t the end points of the other segment. For line segments p₁p₂ and p₃p₄ we will get d₁, d₂, d₃ and d₄.

if none of the d_i are collinear (i.e. d_i !=0) we check if d₁ and d₂ and d₃ and d₄ have opposite orientations (if one is clockwise,other should be counterclockwise). If this condition is true then we know that the line segments straddle each other and hence intersect. If it is false we can straight away say they don’t intersect.

If any d_i is collinear (boundary condition) and the corresponding p_i is on the other line segment, the lines intersect.

Shows the different cases that we encounter visually

bool Intersects(p1, p2, p3, p4)
{
    d1 = CrossProduct (p1p3, p1p2)
    d2 = CrossProduct (p1p4, p1p2)
    d3 = CrossProduct (p3p1, p3p4)
    d4 = CrossProduct (p3p2, p3p4)

    if( ((d1 > 0 and d2<0) or (d2 > 0 and d1<0)) and  ((d3 > 0 and d4<0) or (d4 > 0 and d3<0)))
    {
      then return true
    }
    else if (d1 = 0 and PointOnLine (p3, p4, p1))
    {
       then return true
    }
    else if (d2 = 0 and PointOnLine (p3, p4, p2))
    {
       then return true
    }
    else if (d3 = 0 and PointOnLine (p1, p2, p3))
    {
       then return true
    }
    else if (d4 = 0 and PointOnLine (p1, p2, p4))
    {
       then return true
    }
    else
    {
       return false
    }
}

bool PointOnLine (pi, pj, pk)
{
    if ( Min (xi, xj)<= xk <= Max (xi, xj) and Min (yi, yj)<= yk <= Max (yi, yj) )
    {
        return true
    }
    else
    {
        return false
    }
}

1. Given two points p₁ & p₂ in a co-ordinate plane, is the directed segment p₀p₁ clockwise, counterclockwise or collinear to directed segment p₀p₂? Where p₀ is the origin of the co-ordinate plane
2. Given two directed segments p₀p₁ and p₀p₂, is p₀p₁ clockwise, counterclockwise or collinear to p₀p₂ with respect to the common end point p₀?
3. Given two line segments p₀p₁ and p₁p₂, if we traverse from p₀ to p₂, did we make a left, right or no turn at p₁?
4. Do line segments p₁p₂ and p₃p₄ intersect?

Download the demo application here

Before we proceed any further a few definitions. Clockwise and Counterclockwise are intuitively easy to understand. They have the usual colloquial meaning. There is one thing to note though. A co-ordinate plane is not a watch face! Here we are determining the relative orientations of one segment w.r.t the other. Instead of trying to explain it in words, I will show you a picture (should replace a thousand words!).

The darkly shaded orientation region contains vectors counterclockwise relative to p. The lightly shaded region contains vectors clockwise to p

Two vectors are collinear if they are pointing in the same or opposite direction. In the picture all vectors that lie along the diagonal will be collinear to p.

With definitions out of the way, let us proceed to answer the initial queries that we posed. A brute force method of computing whether two line segments intersect, would be to find the line equations of the form y=mx + c where m is the slope and c the y-intercept and then compute the point of intersection, and verify whether this point lies on both lines. This involves a lot of expensive computational resources. Further this involves division which is sensitive to round-off errors depending upon the precision of the division operation. For e.g. almost parallel line segments will give incorrect results.

The algorithms given here will only use additions, multiplications, subtractions and comparisons ! No trigonometry also !
We do this by computing the cross product. This is a fundamental technique that is at the base of most CG algorithms. Let me say that again. Cross Product is a most fundamental and important technique for solving CG problems. A cross product p₁ X p₂ is defined as the determinant of the matrix comprising of x and y values of the points.

Determinant of the above matrix will be equal to (x1y2-x2y1)

If the cross product is positive then p₁ is clockwise to p₂. A boundary condition occurs if the cross product is 0. In that case p₁ and p₂ are collinear.

Proof: We use trigonometric function tan on the angle formed by the point (x,y), origin (0,0) and (x,0) for both the points. If the ratio of one tangent to other determines orientation depending upon whether the value is greater than 1 or not.

//Clockwise:
x1y2-x2y1>0

//So
x1y2>x2y1

//alternatively
(x1y2)/(x2y1)>1

//rearranging the terms
(y2/x2)/(y1/x1)>1

//Notice that tan θ is the ratio of opposite side by adjacent side
//in a right angled triangle
//so the numerator of the above fraction is tan θ2 and
//denominator tan θ1

(tan θ2)/(tan θ1)>1

If the angle θ2 is greater than θ1
then we have proved that p1 is clockwise to p2

The above technique of using cross product makes for an easy and efficient way to answer Question 1.
To answer Question 2 just involves an extra pre-processing step before doing the cross product. To determine whether two directed segments p₀p₁ and p₀p₂, is p₀p₁ clockwise, counterclockwise or collinear to p₀p₂ with respect to the common end point p₀ we just translate the axis to use p₀ as the origin and use the cross product as above.

// To translate the origin to the common end point p0
//We let p1' (p prime) be the point where 

x1' =x1 - x0 and
y1' =y1 - y0

//We do the above for  p2 and calculate its prime: p2' 

x2' =x2 - x0 and
y2' =y2 - y0

//Then we calculate the cross product of p1' x p2' 

If it is positive then the directed segment p0p1 is clockwise to
directed segment p0p2

In Part 2 we will answer questions 3 & 4 using the techniques and principles learned here.

     string data="query string";
     string encodedData = String.Empty;
       try
       {
           byte[] data_byte = Encoding.UTF8.GetBytes(data);
           encodedData = HttpUtility.UrlEncode(Convert.ToBase64String(data_byte));
        }
        catch (Exception exception)
        {
           //Log exception
        }
        return encodedData;

While this works, it provides only obfuscation, but no security. Anyone can do the reverse:

        string data="encoded data";
        string decodedData = String.Empty;
        try
        {
             byte[] data_byte = Convert.FromBase64String(HttpUtiltity.UrlDecode(data));
             decodedData = Encoding.UTF8.GetString(data_byte);
        }
        catch (Exception exception)
        {
             //Log exception
         }
         return decodedData;

A little more advanced method is to use PasswordDeriveBytes class in .NET to do proper encryption. This has since been replaced with Rfc2898DeriveBytes in .NET 2.0. The reason you would want to use Rfc2898DeriveBytes is because it meets the PKCS #5 standard, which PasswordDerrivedBytes, does not. Both of them are present in System.Security.Cryptography namespace.

What we need to do is:

• Generate the encryption key and IV(Initialization Vector) from the password and salt.
• Create a new instance of the encryptor with the key and IV.
• Encrypt the query string.

We are not done yet. Improper use of Rfc2898DeriveBytes will result in a performance impact on large sets of data. The cause is the call to GetBytes(int32) method on Rfc2898DeriveBytes class. It uses a pseudo-random number generator based on HMACSHA1. GetBytes initializes a new instance of HMAC is the killer in terms of performance. But the redeeming factor is, subsequent calls to GetBytes does not need to do this initialization.

So we change our implementation to do this expensive call once. Since there is no need to create a new instance of Rfc2898DeriveBytes for each call to encrypt, we will use the same key but change the IV for each message. So remove Rfc2898DeriveBytes from the Encrypt method and pass along the key and IV instead of the password and salt.

Putting all this together here is the final code (fast and efficient):

      public static class MyHelper
      {

          #region Private variables and Constants
          private const string ENCRYPTION_KEY = "Wx0Te1rc0pA";
          // Generated from Pass Phrase  "xxxxxxxx12012010" or some pass phrase that you can remember from
          // https://www.bigbiz.com/genkey.html Key Generator Site

          private const string QUERY_PARTS_DELIMITOR = "&";
          private const string QUERY_PARAMS_DELIMITOR = "=";

          ///
          /// The salt value used to strengthen the encryption.
          ///
          private readonly static byte[] SALT = Encoding.ASCII.GetBytes(ENCRYPTION_KEY);
          private readonly static byte[] key;
          private readonly static byte[] iv;
          private static readonly Rfc2898DeriveBytes keyGenerator;

          #endregion

         #region Constructor

         static MyHelper()
         {
            //We create the Rfc2898DerveBytes once as
            //Rfc2898DeriveBytes uses a pseudo-random number generator based on HMACSHA1.
            //When calling GetBytes it initializes a new instance of HMAC which takes some time.
            //Subsequent calls to GetBytes does not need to do this initialization.
            keyGenerator =new Rfc2898DeriveBytes(ENCRYPTION_KEY,SALT);
            key = keyGenerator.GetBytes(32);
            //Generate Initialization Vector - This will be less expensive as we have already intialized Rfc2898DeriveBytes
            iv = keyGenerator.GetBytes(16);
        }

       #endregion

       #region Encrypt/Decrypt Methods

        ///

        /// Encrypts any string using the Rijndael algorithm.
        /// 

        ///
The string to encrypt.
        ///
The name of the query string paramater
        /// A Base64 encrypted string.
        public static string Encrypt(string inputText, string queryStringParam)
        {
            //Create a new RijndaelManaged cipher for the symmetric algorithm from the key and iv
            RijndaelManaged rijndaelCipher = new RijndaelManaged {Key = key, IV = iv};

            byte[] plainText = Encoding.Unicode.GetBytes(inputText);

            using (ICryptoTransform encryptor = rijndaelCipher.CreateEncryptor())
            {
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                    {
                        cryptoStream.Write(plainText, 0, plainText.Length);
                        cryptoStream.FlushFinalBlock();
                        return "?" + queryStringParam + "=" + Convert.ToBase64String(memoryStream.ToArray());
                    }
                }
            }
        }

        ///

        /// Decrypts a previously encrypted string.
        /// 

        ///
The encrypted string to decrypt.
        /// A decrypted string.
        public static string Decrypt(string inputText)
        {
            RijndaelManaged rijndaelCipher = new RijndaelManaged();
            byte[] encryptedData = Convert.FromBase64String(inputText);

            using (ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(key, iv))
            {
                using (MemoryStream memoryStream = new MemoryStream(encryptedData))
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                    {
                        byte[] plainText = new byte[encryptedData.Length];
                        int decryptedCount = cryptoStream.Read(plainText, 0, plainText.Length);
                        return Encoding.Unicode.GetString(plainText, 0, decryptedCount);
                    }
                }
            }
        }

        #endregion

       }

The only draw back is this doesn’t give you full security. This method will provide basic security in terms of stopping the hacker from deterministically manipulating the encrypted string. So it is a more a deterrence than a verification strategy. We can tell if someone tampers with the encrypted string only if the decryption ‘fails’ to decrypt to something you recognize or expect.

GodMode: A feature that transforms a folder to a shortcut pointing to some windows tasks, just by appending a folder name with a period (‘.’), followed by a special string (‘{GUID}’).

It includes direct access to all kinds of settings, from choosing a location to managing power settings to identifying biometric sensors, to name a few.

To keep them all grouped together and ‘know’ what they do with a glance, I followed this pattern-
[folder name].{GUID}
In my case, I chose ‘GodMode’ as the folder name. Once the shortcut is made, I change the name to the following format before moving on to the next God Mode- [folder name].[feature name] For e.g. with the Control Panel God Mode, I would call it something like ‘GodMode.ControlPanel’.

This is how it looks on my computer:

God Mode Folders

Here is a list of God Modes that I have found so far with a short description:

Control Panel : {ED7BA470-8E54-465E-825C-99712043E01C}
Description: A shortcut to all Control Panel functions

Location Info : {00C6D95F-329C-409a-81D7-C46C66EA7F33}
Description: A shortcut to set up default location for programs to use when a location sensor, such as GPS receiver, is unavailable. On can also enter Geographic location (latitude and longitude) too.

Biometric Info : {0142e4d0-fb7a-11dc-ba4a-000ffe7ab428}
Description: A shortcut showing the information of any biometric device like fingerprint reader etc, if installed.

Power Plan : {025A5937-A6BE-4686-A844-36FE4BEC8B6D}
Description: A shortcut to select the power consumption settings for your computer.

System Tray : {05d7b0f4-2121-4eff-bf6b-ed3f69b894d9}
Description: A shortcut which opens the icon and notifications settings, where you can set whether you want to show/hide icons in system tray and whether to show only notifications etc.

Windows Vault : {1206F5F1-0569-412C-8FEC-3204630DFB70}
Description: A shortcut which points to Windows Vault. We can store credentials for automatic logon here.

Program Install: {15eae92e-f17a-4431-9f28-805e482dafd4}
Description: A shortcut to install a program from the network.

Default Programs: {17cd9488-1228-4b2f-88ce-4298e93e0966}
Description: A shortcut to choose programs that Windows uses by default.

Manage Wireless: {1FA9085F-25A2-489B-85D4-86326EEDCD87}
Description: A shortcut to manage wireless networks.

Manage Network: {208D2C60-3AEA-1069-A2D7-08002B30309D}
Description: A shortcut to network computers, websites, FTP sites etc.
Remarks: This God Mode doesn’t allow us to rename the folder to anything else. It keeps changing back to ‘Network (MS)’

Manage Network: {1D2680C9-0E2A-469d-B787-065558BC7D43}
Description: A shortcut to GAC (Global Assembly Cache).
Remarks: This God Mode doesn’t change its folder icon or hide its GUID string like others. But it correctly points to the GAC on the computer.

Computer Drives: {20D04FE0-3AEA-1069-A2D8-08002B30309D}
Description: A shortcut which shows the current drives on the computer.

Printers: {2227A280-3AEA-1069-A2DE-08002B30309D}
Description: A shortcut to the printers added to the computer.

Remote Connections: {241D7C96-F8BF-4F85-B01F-E2B043341A4B}
Description: A shortcut to manage your RemoteApp and Desktop Connections.

Windows Firewall: {4026492F-2F69-46B8-B9BF-5654FC07E423}
Description: A shortcut to setup Windows Firewall settings to prevent malicious hackers from getting access to your computer.

Computer Performance: {78F3955E-3B90-4184-BD14-5397C15F1EFC}
Description: A shortcut to get your computer’s speed and performance information.