CTYPE html>

Clipping

I am using Hearn and Baker for this.

The program in the last project had a very bad clipping

    SetPoint: function(x,y,r,g,b) {
       if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
          // this if is a very bad form of clipping
          if (x >= this.viewportXMin && x <= this.viewportXMax
                  && y>=this.viewportYMin && y <= this.viewportYMax) {
               this.frameBuffer[x][y].R = Clamp(0,255,r);
               this.frameBuffer[x][y].G = Clamp(0,255,g);
               this.frameBuffer[x][y].B = Clamp(0,255,b);
          }
       }
       return;
    },

Why is this bad?
- What if a line never appears in the window?
It is even worse for polygons. (Why?)

Clipping is the process of determining which primitives, or parts of primitives are visible or inside the viewport.
- Clipping is performed after the user specifies where the objects will be and what we are looking at.
- While we have not yet discussed this, operations only involve vertices.
The general problem is given a window (x_min,y_min) to (x_max,y_max), and a primitive p
1. Does all of p lie inside the window?
2. Does all of p lie outside the window?
3. Does part of p lie inside the window?
- In case 1, p can be rendered with no further action.
- In case 2, p can be discarded.
  - This is frequently labeled as rejected or culled
- In case 3, we would like to compute p^' such that p^' meets criteria 1.
Let's look at our four primitives
- Point
  - A point (x,y) is trivial
  - If x_min ≤ x ≤ x_max and y_min ≤y ≤ y_max then draw the point.
  - Otherwise do not draw the point.
  - Note, drawing the point means pass it along to rasterization.
  - There is no partial view of the point.
- Line
  - Line 3 is trivially accepted.
  - Line 9 could be trivially rejected (both x endpoints are too high and both y endpoints are too low)
  - Lines 1, 7 and 8 can be rejected, but take more work.
  - Lines 5 and 6 clearly need clipped.
  - Lines 2 and 4 need clipped too, but are increasingly more difficult.
  - A naive approach here could be problematic (lines 1,2,4,7,8)
  - A brute force approach (compute line intersections) would be too computationally expensive.
  - We will look at two algorithms.
    - Cohen-Sutherland
      - To each endpoint, a 4 bit code is assigned: b₃b₂b₁b₀
        
        b₀ = x < x_min
        b₁ = x > x_max
        b₂ = y < y_min
        b₃ = y > y_max
    - Assign a code to each endpoint, let these be c₁ and c₂
      1. if c₁ == c₂== 0, accept the point (line 3)
      2. else if c₁ !=0 and c₂ == 0 or c₁==0 and c₂ != 0, clip the line. (lines 5 and 6)
      3. else if c₁ & c₂ != 0 discard the line. (lines 7,8 and 9)
      4. else (c₁ & c₂ == 0) Can't tell, clip the line against one of the edges and check again. (Lines 1 and 4)
    - Notice the bit code generated tells us where to clip the line.
    - Clipping the line.
      - Use point slope form.
      - if b₀ ==1,
        
        x = x_min
        y = m(p2.x - x_min) + p2.y
      - The same for other points.
    - Cohen Sutherland works in multiple dimensions.
    - But horizontal and vertical lines are problematic
  - Liang-Barsky
    - Represent the lines as parametric equations
      - x(α) = (1-α)p1.x + αp2.x
      - y(α) = (1-α)p1.y + αp2.y
    - For the infinite extension of the line compute where the line will cross
      1. y = y_min , α₁
      2. x = x_min , α₂
      3. y = y_max , α₃
      4. x = x_max , α₄
    - By observing the order of α₁ - α₄, we can tell if the line needs clipped or can be discarded.
    - The alpha values for the endpoints are 0 and 1.
      - Do the examples above.
      - For line 1,
        
        Order α₁,α₃,α₂,α₄
        enter exit enter exit
        Reject, it is outside of the window
      - For line 2,
        
        α₁ < 0 < α₂ < α₃ < 1 < α₄
        enter, enter, exit, exit,
        clip at α₂,α₃
      - For line 3
        
        α₁ < α₂ < 0 < 1 < α₃ < α₄
        the line does an enter enter exit exit
        So the line is ok.
      - For line 4
      - 0 < α₁ < α₂ < α₃ < α₄ < 1
      - enter enter exit exit.
      - clip at α₂, α₃
    - Efficient computation of α_n
    - ```
    y(α₃) = (1-α₃)p1.y + α₃p2.y     note y(α₃) = y_max
    y_max    = p1.y - α₃p1.y + α₃p2.y
    y_max - p1.y = α₃(p2.y-p1.y)
     
         y_max - p1.y
    α₃ = ------------
         p2.y - p1.y
    
    α₃(p2.y-p1.y) = y_max - p1.y 
        =  α₃Δy    
    
        define Δy_max = y_max - p1.y
        so α₃Δy  = Δy_max, which is only integer computation.
    		     
```
- The other alpha values can be determined in a similar manner.

Polygon clipping for the next set of notes.