title: Intersection between two rectangles in 3D
body: <p>To get the line of intersection between two rectangles in 3D, I converted them to planes, then get the line of intersection using cross product of their normals, then I try to get the line intersection with each line segment of the rectangle.</p>
  
  <p>The problem is the line is parallel to three segments, and intersect with only one in NAN,NAN,NAN which is totally wrong. Can you advise me what's wrong in my code?</p>
  
  <p>I use vector3 from this link <a href="http://www.koders.com/csharp/fidCA8558A72AF7D3E654FDAFA402A168B8BC23C22A.aspx" rel="nofollow">http://www.koders.com/csharp/fidCA8558A72AF7D3E654FDAFA402A168B8BC23C22A.aspx</a></p>
  
  <p>and created my plane class as following </p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace referenceLineAlgorithm
  {
  struct Line
  {
  
      public Vector3 direction;
      public Vector3 point;
  
  }
  
  struct lineSegment
  {
  
      public Vector3 firstPoint;
      public Vector3 secondPoint;
  
  }
  
  class plane_test
  {
      public enum Line3DResult
      {
          Line3DResult_Parallel = 0,
          Line3DResult_SkewNoCross = 1,
          Line3DResult_SkewCross = 2
      };
  
      #region Fields
  
      public Vector3 Normal;
      public float D;
      public Vector3[] cornersArray;
      public Vector3 FirstPoint;
      public Vector3 SecondPoint;
      public Vector3 temp;
      public Vector3 normalBeforeNormalization;
  
  
      #endregion
  
      #region constructors
  
      public plane_test(Vector3 point0, Vector3 point1, Vector3 point2, Vector3 point3)
      {
          Vector3 edge1 = point1 - point0;
          Vector3 edge2 = point2 - point0;
          Normal = edge1.Cross(edge2);
          normalBeforeNormalization = Normal;
  
          Normal.Normalize();
          D = -Normal.Dot(point0);
  
          ///// Set the Rectangle corners 
          cornersArray = new Vector3[] { point0, point1, point2, point3 };
  
      }
  
      #endregion
  
      #region Methods
      /// &lt;summary&gt;
      /// This is a pseudodistance. The sign of the return value is
      /// positive if the point is on the positive side of the plane,
      /// negative if the point is on the negative side, and zero if the
      ///  point is on the plane.
      /// The absolute value of the return value is the true distance only
      /// when the plane normal is a unit length vector.
      /// &lt;/summary&gt;
      /// &lt;param name="point"&gt;&lt;/param&gt;
      /// &lt;returns&gt;&lt;/returns&gt;
      public float GetDistance(Vector3 point)
      {
          return Normal.Dot(point) + D;
      }
  
      public void Intersection(plane_test SecondOne)
      {
          ///////////////////////////// Get the parallel to the line of interrsection (Direction )
          Vector3 LineDirection = Normal.Cross(SecondOne.Normal);
  
          float d1 = this.GetDistance(LineDirection);
          float d2 = SecondOne.GetDistance(LineDirection);
  
          temp = (LineDirection - (this.Normal * d1) - (SecondOne.Normal * d2));
  
          temp.x = Math.Abs((float)Math.Round((decimal)FirstPoint.x, 2));
          temp.y = Math.Abs((float)Math.Round((decimal)FirstPoint.y, 2));
  
          Line line;
          line.direction = LineDirection;
          line.point = temp;
  
          ////////// Line segments 
  
          lineSegment AB, BC, CD, DA;
  
          AB.firstPoint = cornersArray[0]; AB.secondPoint = cornersArray[1];
          BC.firstPoint = cornersArray[1]; BC.secondPoint = cornersArray[2];
          CD.firstPoint = cornersArray[2]; CD.secondPoint = cornersArray[3];
          DA.firstPoint = cornersArray[3]; DA.secondPoint = cornersArray[0];
  
          Vector3 r1 = new Vector3(-1, -1, -1);
          Vector3 r2 = new Vector3(-1, -1, -1);
          Vector3 r3 = new Vector3(-1, -1, -1);
          Vector3 r4 = new Vector3(-1, -1, -1);
  
          /*
          0,0 |----------------| w,0
              |                |
              |                |
          0,h |________________|  w,h
  
  
           */
  
          IntersectionPointBetweenLines(AB, line, ref r1);
          IntersectionPointBetweenLines(BC, line, ref r2);
          IntersectionPointBetweenLines(CD, line, ref r3);
          IntersectionPointBetweenLines(DA, line, ref r4);
  
          List&lt;Vector3&gt; points = new List&lt;Vector3&gt;();
          points.Add(r1);
          points.Add(r2);
          points.Add(r3);
          points.Add(r4);
          points.RemoveAll(
  
             t =&gt; ((t.x == -1) &amp;&amp; (t.y == -1) &amp;&amp; (t.z == -1))
  
  
             );
  
          if (points.Count == 2)
          {
              FirstPoint = points[0];
              SecondPoint = points[1];
  
  
          }
  
  
  
  
      }
  
      public Line3DResult IntersectionPointBetweenLines(lineSegment first, Line aSecondLine, ref Vector3 result)
      {
          Vector3 p1 = first.firstPoint;
          Vector3 n1 = first.secondPoint - first.firstPoint;
  
  
          Vector3 p2 = aSecondLine.point;
          Vector3 n2 = aSecondLine.direction;
  
          bool parallel = AreLinesParallel(first, aSecondLine);
          if (parallel)
          {
  
              return Line3DResult.Line3DResult_Parallel;
          }
          else
          {
              float d = 0, dt = 0, dk = 0;
              float t = 0, k = 0;
  
              if (Math.Abs(n1.x * n2.y - n2.x * n1.y) &gt; float.Epsilon)
              {
                  d = n1.x * (-n2.y) - (-n2.x) * n1.y;
                  dt = (p2.x - p1.x) * (-n2.y) - (p2.y - p1.y) * (-n2.x);
                  dk = n1.x * (p2.x - p1.x) - n1.y * (p2.y - p1.y);
              }
              else if (Math.Abs(n1.z * n2.y - n2.z * n1.y) &gt; float.Epsilon)
              {
                  d = n1.z * (-n2.y) - (-n2.z) * n1.y;
                  dt = (p2.z - p1.z) * (-n2.y) - (p2.y - p1.y) * (-n2.z);
                  dk = n1.z * (p2.z - p1.z) - n1.y * (p2.y - p1.y);
              }
              else if (Math.Abs(n1.x * n2.z - n2.x * n1.z) &gt; float.Epsilon)
              {
                  d = n1.x * (-n2.z) - (-n2.x) * n1.z;
                  dt = (p2.x - p1.x) * (-n2.z) - (p2.z - p1.z) * (-n2.x);
                  dk = n1.x * (p2.x - p1.x) - n1.z * (p2.z - p1.z);
              }
  
              t = dt / d;
              k = dk / d;
  
              result = n1 * t + p1;
  
              // Check if the point on the segmaent or not 
             // if (! isPointOnSegment(first, result))
              //{
                 // result = new Vector3(-1,-1,-1);
  
  
             // }
  
              return Line3DResult.Line3DResult_SkewCross;
  
          }
  
  
  
      }
      private bool AreLinesParallel(lineSegment first, Line aSecondLine)
      {
          Vector3 vector = (first.secondPoint - first.firstPoint);
          vector.Normalize();
  
          float kl = 0, km = 0, kn = 0;
          if (vector.x != aSecondLine.direction.x)
          {
              if (vector.x != 0 &amp;&amp; aSecondLine.direction.x != 0)
              {
                  kl = vector.x / aSecondLine.direction.x;
              }
          }
          if (vector.y != aSecondLine.direction.y)
          {
              if (vector.y != 0 &amp;&amp; aSecondLine.direction.y != 0)
              {
                  km = vector.y / aSecondLine.direction.y;
              }
          }
          if (vector.z != aSecondLine.direction.z)
          {
              if (vector.z != 0 &amp;&amp; aSecondLine.direction.z != 0)
              {
                  kn = vector.z / aSecondLine.direction.z;
              }
          }
  
          // both if all are null or all are equal, the lines are parallel
          return (kl == km &amp;&amp; km == kn);
  
  
  
  
      }
  
      private bool isPointOnSegment(lineSegment segment, Vector3 point)
      {
          //(x - x1) / (x2 - x1) = (y - y1) / (y2 - y1) = (z - z1) / (z2 - z1)
          float component1 = (point.x - segment.firstPoint.x) / (segment.secondPoint.x  - segment.firstPoint.x);
          float component2 = (point.y - segment.firstPoint.y) / (segment.secondPoint.y - segment.firstPoint.y);
          float component3 = (point.z - segment.firstPoint.z) / (segment.secondPoint.z - segment.firstPoint.z); 
  
          if ((component1 == component2) &amp;&amp; (component2 == component3))
          {
              return true;
  
  
          }
          else
          {
              return false;
  
          }
  
      }
  
      #endregion
  }
  }
  
  static void Main(string[] args)
      {
  
          //// create the first plane points 
          Vector3 point11 =new Vector3(-255.5f, -160.0f,-1.5f) ;    //0,0
          Vector3 point21 = new Vector3(256.5f, -160.0f, -1.5f);   //0,w
          Vector3 point31 = new Vector3(256.5f, -160.0f, -513.5f); //h,0
          Vector3 point41 = new Vector3(-255.5f, -160.0f, -513.5f); //w,h 
  
          plane_test plane1 = new plane_test(point11, point21, point41, point31);
  
          //// create the Second plane points 
  
          Vector3 point12 = new Vector3(-201.6289f, -349.6289f, -21.5f);
          Vector3 point22 =new Vector3(310.3711f,-349.6289f,-21.5f);
          Vector3 point32 = new Vector3(310.3711f, 162.3711f, -21.5f);
          Vector3 point42 =new Vector3(-201.6289f,162.3711f,-21.5f);
          plane_test plane2 = new plane_test(point12, point22, point42, point32);
  
  
          plane2.Intersection(plane1);
  
  
  
      }
  </code></pre>
  
  <p>and this is test values 
  Best regards </p>