Konvensi umum akan digunakan:

    * Bahwa koordinat pixel peningkatan kanan dan arah bawah (misalnya bahwa pixel di (1,1) secara langsung di atas pixel di (1,2)), dan
    * Bahwa pusat piksel memiliki koordinat integer.
Titik-titik ujung garis adalah piksel pada (x0, y0) dan (x1, y1), dimana koordinat pertama dari pasangan adalah kolom dan baris kedua adalah.
Algoritma ini akan disajikan awalnya hanya untuk octant di mana segmen terbenam dan ke kanan (x0, â § x1 dan y0, â § y1), dan proyeksi horisontal x1, x0 AI lebih panjang dari proyeksi vertikal y1, AI y0 (garis memiliki kemiringan yang absolut nilai kurang dari 1 dan lebih besar dari 0.) Dalam octant ini, untuk setiap kolom x antara x0 dan x1, ada tepat satu baris y (dihitung dengan algoritma) yang berisi piksel baris, sedangkan setiap baris antara y0 dan y1 dapat berisi piksel rasterized ganda.
algoritma Bresenham's memilih integer y sesuai dengan pusat pixel yang terdekat dengan y (pecahan) yang ideal untuk hal yang sama x; pada kolom berturut-turut y bisa tetap sama atau meningkat 1. Persamaan umum garis melalui endpoint diberikan oleh:

    \ Frac {y - y_0} {y_1-y_0} = \ frac {x-x_0} {x_1-x_0}.
Karena kita tahu kolom, x, baris pixel itu, y, diberikan oleh pembulatan kuantitas ini ke integer terdekat:

    y = \ frac {y_1-y_0} {x_1-x_0} (x-x_0) + y_0.
Kemiringan (y1, AI y0) / (x1, x0 AI) tergantung pada titik akhir hanya koordinat dan dapat precomputed, dan y ideal untuk nilai integer x berturut-turut dapat dihitung mulai dari y0 dan berulang kali menambahkan lereng.
Dalam prakteknya, algoritma dapat melacak, bukan nilai y kemungkinan besar, nilai kesalahan kecil antara, àí0.5 dan 0,5: jarak vertikal antara bulat dan nilai y yang tepat untuk saat ini x. Setiap kali x meningkat, kesalahan meningkat dengan kemiringan; jika melebihi 0,5, Pengubahan pola Postscript y ditingkatkan sebesar 1 (baris terus di baris berikutnya bawah raster) dan kesalahan adalah decremented sebesar 1,0.
Dalam plot pseudocode contoh berikut (x, y) plot huruf a dan mengembalikan nilai absolut abs:

 fungsi garis (x0, x1, y0, y1)
     int deltax: = x1 - x0
     int deltay: = y1 - y0
     nyata error: = 0
     deltaerr nyata: = abs (deltay / deltax) / / Asumsikan deltax = 0 (garis tidak vertikal),!
           / / Perhatikan bahwa divisi ini perlu dilakukan dengan cara yang melindungi bagian pecahan
     int y: = y0
     untuk x dari x0 ke x1
         plot (x, y)
         error: = error + deltaerr
         jika kesalahan, â • 0,5 maka
             y: = y + 1
             error: error = - 1,0
[Sunting] Generalisasi
Versi di atas hanya menangani baris yang turun ke kasus pertama right.The memang memungkinkan kita untuk menggambar garis yang masih kemiringan ke bawah tetapi kepala ke arah yang berlawanan. Ini adalah masalah sederhana menukar poin awal jika x0> x1. Rumit adalah menentukan cara menggambar garis yang naik. Untuk melakukan ini, kita memeriksa apakah y0, â • y1, jika demikian, kita langkah y dengan -1 bukan 1. Terakhir, kita masih perlu untuk menggeneralisasi algoritma untuk menggambar garis ke segala arah. Sampai sekarang kita hanya bisa menggambar garis dengan kemiringan kurang dari satu. Untuk dapat menggambar garis dengan kemiringan curam, kita mengambil keuntungan dari fakta bahwa garis yang curam bisa tercermin di garis y = x untuk mendapatkan garis dengan kemiringan kecil. Efeknya adalah untuk switch x dan variabel y seluruh, termasuk switching parameter untuk plot. Kode terlihat seperti ini:

 fungsi garis (x0, x1, y0, y1)
     boolean curam: = abs (y1 - y0)> abs (x1 - x0)
     jika curam maka
         swap (x0, y0)
         swap (x1, y1)
     jika x0> x1 lalu
         swap (x0, x1)
         swap (y0, y1)
     int deltax: = x1 - x0
     int deltay: = abs (y1 - y0)
     nyata error: = 0
     nyata deltaerr: deltay = / deltax
     int ystep
     int y: = y0
     jika y0 <y1 kemudian ystep: = 1 ystep lain: = -1
     untuk x dari x0 ke x1
         jika curam maka plot (y, x) lain plot (x, y)
         error: = error + deltaerr
         jika kesalahan, â • 0,5 maka
             y: y = + ystep
             error: error = - 1,0
Fungsi sekarang menangani semua lini dan menerapkan algoritma Bresenham lengkap itu. [Sunting] Optimasi
Masalah dengan pendekatan ini adalah bahwa komputer beroperasi relatif lambat pada angka-angka pecahan seperti kesalahan dan deltaerr, apalagi, kesalahan dapat mengumpulkan lebih dari penambahan floating-point banyak. Bekerja dengan baik bilangan bulat akan lebih cepat dan akurat. Trik yang kami gunakan adalah dengan mengalikan semua angka-angka pecahan di atas dengan deltax, yang memungkinkan kita untuk menyatakan mereka sebagai bilangan bulat. Satu-satunya masalah yang tersisa adalah 0,5 konstan, menangani Äîto dengan ini, kita mengubah inisialisasi dari kesalahan variabel, dan invert untuk optimasi kecil tambahan. Program baru terlihat seperti ini:

 fungsi garis (x0, x1, y0, y1)
     boolean curam: = abs (y1 - y0)> abs (x1 - x0)
     jika curam maka
         swap (x0, y0)
         swap (x1, y1)
     jika x0> x1 lalu
         swap (x0, x1)
         swap (y0, y1)
     int deltax: = x1 - x0
     int deltay: = abs (y1 - y0)
     int error: deltax = / 2
     int ystep
     int y: = y0
     jika y0 <y1 kemudian ystep: = 1 ystep lain: = -1
     untuk x dari x0 ke x1
         jika curam maka plot (y, x) lain plot (x, y)
         error: error = - deltay
         jika <error 0 maka
             y: y = + ystep
             error: error = + deltax
Catatan: Jika Anda perlu untuk mengontrol titik-titik dalam urutan penampilan (misalnya untuk mencetak beberapa garis putus-putus berturut-turut), Anda akan harus menyederhanakan kode ini dengan melewatkan swap 2:
fungsi garis (x0, x1, y0, y1)
     boolean curam: = abs (y1 - y0)> abs (x1 - x0)
     jika curam maka
         swap (x0, y0)
         swap (x1, y1)
     int deltax: = abs (x1 - x0)
     int deltay: = abs (y1 - y0)
     int error: deltax = / 2
     int ystep
     int y: = y0
  
     int inc REM ditambahkan
     jika x0 <x1 kemudian inc: = 1 lain inc: = -1 REM ditambahkan
 
     jika y0 <y1 kemudian ystep: = 1 ystep lain: = -1
     untuk x dari x0 untuk x1 dengan kenaikan inc REM berubah
         jika curam maka plot (y, x) lain plot (x, y)
         kenaikan REM di sini variabel untuk mengontrol kemajuan gambar garis
         error: error = - deltay
         jika <error 0 maka
             y: y = + ystep
             error: error = + deltax
[Sunting] Penyederhanaan
Hal ini lebih mungkin untuk menghilangkan swap di inisialisasi dengan mempertimbangkan kesalahan perhitungan untuk kedua arah secara simultan:

 fungsi garis (x0, y0, x1, y1)
   dx: = abs (x1-x0)
   dy: = abs (y1-y0)
   jika x0 <x1 kemudian sx: = 1 sx lain: = -1
   jika y0 <y1 kemudian sy: = 1 lain sy: = -1
   err: = dx-dy
 
   putaran
     setPixel (x0, y0)
     jika x0 = x1 dan y1 = y0 keluar loop
     e2: = 2 * berbuat salah
     jika e2>-dy lalu
       err: = sesat - dy
       x0: = x0 + sx
     berakhir jika
     jika e2 <dx lalu
       err: = kesalahan + dx
       y0: = y0 + sy
     berakhir jika
   loop end