Clipping

• This is part of chapter 8.
  • We will be examining several topics from this chapter.
• 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 view frustum
  • Others will be partially inside of the frustum.
  • We probably don't want to try to draw everything
• Clipping will allow us reduce the work in rendering the scene.
• At the program level we can do this with a bounding box.
  • Compute the location of the view frustum on the CPU side.
    • We could really just do a bounding box if you wish.
  • Declare a box, or sphere that surrounds an object.
    • Why these two objects?
      • If the center of the sphere is less than the radius of the sphere from any corner of the view box we are potentially inside of the view box.
    • We could do the same for a cube but there are more computations.
  • Transform this box or sphere
    • We just need to carefully scale the radius of the sphere.
    • And translate the center location.
    • Again, more work with the box
  • None of this is computationally expensive
    • Sphere less accurate but two points to compute.
    • Six points on a cube, but more accurate.
    • And only one computation per object.
  • And can be used for other things
    • Route planning
    • Avoiding running into objects (movement restriction)
  • If the sphere or the cube is inside or intersects with the view volume, tell opengl to draw it.
  • If not, don't
• In the pipeline, clipping occurs after transformation to the clipping volume
  • Duh
  • But before projection
  • This is to allow
    • Preservation of the z coordinate for depth related operations
    • The ability to clip items beyond the far plane.
  • This coordinate system is called normalized device coordinates
    • They are not related to any other system
    • The modeling or camera system has been "removed"
    • The display (window) is not yet added.
  • All coordinates should be within the cube
    • -w ≤ x ≤ w
    • -w ≤ y ≤ w
    • -w ≤ z ≤ w
  • Anything outside of this cube should be removed (or clipped).
• 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 first bit represents y>y_max
  • The second bit represents y< y_min
  • The first bit represents x>x_max
  • The second bit represents x< x_min
  • 
  • Assign this bitcode to each point.
  • Assume the box is (-1,1) to (1,1)
  • What is teh bit code for

    Point	Coordinates	outcode
    A	(.3, .3)	0000
    B	(.5, .8)	0000
    C	(-1.2, .4)	0001
    D	(1.5, .4)	0010
    E	(-1.1, 1.2)	1001
    F	(.9, -.2)	0100
    G	(1.1, 1.1)	1010

  • Consider line AB
    • Test 1
    • O_A = O_B = 0: Accept
  • Consider CB
    • First test fails.
    • Test 2
    • O_C ≠ 0, O_B = 0: Clip
    • The same with AC but other order.
    • 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. (Consider line AG)
  • Consider CE
    • First two tests fail
    • Test 3
    • O_C & O_E != 0 (0001 & 1001 = 0001): Reject
    • Both are outside of the same edge.
  • Consider CD
    • First three tests fail
    • Test 4
    • O_C & O_D = 0 (0001 & 0010 = 0000): Reject
    • Clip against one edge and repeat.
  • All clipping is done using y=mx+b
  • 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(α) = (1-α)p₁ + αp₂
      • x(α) = (1-α)x₁ + αx₂
      • y(α) = (1-α)y₁ + α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?
  • Derive equations to find α, and αδy
• 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.
    • OpenGL has a tessellation shader
  • 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.
    • Essentually 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 crosss 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
      

    •