Clipping

• In clipping we eliminate items which we don't need to draw.
  • Consider a scene in a game
  • Many objects will be outside of the viewable area
  • Others will be partially inside of the viewable area.
  • We probably don't want to try to draw everything
• Clipping will allow us reduce the work in rendering the scene.
  • We can eliminate objects that can not be seen.
• A line clipper is responsible for
  • Accepting lines that are within the cube
  • Rejecting or culling lines that are outside of the cube
  • clipping lines that cross the boundaries.
• We will look at 2D clipping, but this is easy to extend to 3d.
• A brute force algorithm
  • Compute the x and y intersection with each wall of the clipping plane using y=mx+b for the line.
• Cohen-Sutherland clipping algorithm
  • Divide the plane into 9 regions.
  • The center contains items that are inside of the clip region.
  • Assign a 4 bit outcode to each region.
    • The MSB bit represents y>y_max
    • The second bit represents y< y_min
    • The third bit represents x>x_max
    • The LSB bit represents x< x_min
  • 
  • Assign this bitcode to each point.
  • Use this code
  • Test 1
    • Consider line a AB in the box.
    • 
    • O_A = O_B = 0: Accept
  • Test 2
    • Consider CB with one endpoint in the box and one outside.
    • 
    • First test fails.
    • If O_C ≠ 0, O_B = 0: Clip
    • If O_B ≠ 0, O_C = 0: Clip
    • The non zero outcode indicates which point will be clipped off
    • Clip against one of the indicated sides, compute a new outcode
    • Repeat the process.
  • Test 3
    • Consider CE a line completely below the box.
    • 
    • First test fails.
    • First two tests fail
    • O_C & O_E != 0
    • (0001 & 1001 = 0001): Reject
    • Both are outside of the same edge.
    • This line can be discarded.
  • Test 4
    • Consider CD a line crossing the box.
    • 
    • First three tests fail
    • O_C & O_D = 0
    • (0001 & 0010 = 0000): Reject
    • Clip against one edge and repeat.
  • All clipping is done using y=mx+b, or some form of this.
  • But this has problems for vertical lines. (m is undefined)
  • Is this better than brute force?
• Liang-Barsky
  • Uses parametric equations for a line
    • $ p(\alpha) = x_1(1-\alpha) + x_2\alpha $
      • Let $ \alpha_2 $ be the point where the line crosses the left most clip line.
      • This is at the point $(x_n, y?)$ where $x_n$ is the value of the x value of the clipping line.
      • $ x_n = x_1(1-\alpha_2) + x_2\alpha_2 $
        • $ x_n = x_1-x_1\alpha_2 + x_2\alpha_2 $
        • $ x_n - x_1 = -x_1\alpha_2 + x_2\alpha_2 $
        • $ x_n - x_1 = (-x_1 + x_2)\alpha_2 $
        • $ \frac{x_n - x_1} {x_2-x1} = \alpha_2 $
    • We can find the same for $\alpha_4$ where it crosses the rightmost.
    • And for $\alpha_1 $ and $\alpha_3 $, the corresponding points for y.
  • For this find
    • α₁ where the line crosses the lower x clipping line
    • α₂ where the line crosses the left y clipping line
    • α₃ where the line crosses the upper x clipping line
    • α₄ where the line crosses the right x clipping line
  • 
    • In this case 0 ≤ α₁ ≤ α₂ ≤ α₃ ≤ α₄ ≤ 1
    • The line needs to be clipped and the two endpoints are at α₂ and α₃
  • Consider 0 ≤ α₁ ≤ α₃ ≤ α₂ ≤ α₄ ≤ 1
    • The line is completely to the left of and above the volume so it can be discarded.
  • What makes α values less than 0?
  • What makes α values greater than 1?
  • We can derive an integer based computation to do this.
• Polygon clipping
  • We can just use C-S or L-B if we have triangles.
    • It might become a non-triangle
    • But it will still be a single convex polygon.
    • The author says adding more polygons can be problematic
    • But there is the fan algorithm, as well as other tessellation algorithms.
    • So our polygons can be returned to triangles if we wish.
    • When we get to OpenGL there is a way to deal with this.
  • It is more of a problem with convex polygons
    • It is very easy to create MANY polygons in this case.
  • Clipping against an arbitrary convex polygon is an easy extension
    • The Sutherland-Hodgeman algorithm is the (as far as I know) choice for this.
    • Essentially form a list of the edges of the polygon being clipped
    • Send this list through a pipeline of clipping against edge
      • This will add/change a vertex if a line crosses an edge
      • It will delete both vertexes of a line is outside of an edge.
      • It will change nothing for a line inside of an edge.
    • Pseudo code lifted from wikipedia

    •   List outputList = subjectPolygon;   
        for (Edge clipEdge in clipPolygon) do
           List inputList = outputList;
           outputList.clear();
           Point S = inputList.last;
           for (Point E in inputList) do
              if (E inside clipEdge) then
                 if (S not inside clipEdge) then
                    outputList.add(ComputeIntersection(S,E,clipEdge));
                 end if
                 outputList.add(E);
              else if (S inside clipEdge) then
                 outputList.add(ComputeIntersection(S,E,clipEdge));
              end if
              S = E;
           done
        done
      

    •