Implementing Image Filters in Swift

In this segment, you’ll implement three image processing algorithms in Swift: grayscale conversion, blur effect, and brightness adjustment. You’ll work directly with raw pixel data, learning how to manipulate individual color channels to create visual effects.

Image processing algorithms operate on pixel arrays, transforming color values according to mathematical formulas. Swift’s type safety and array handling make it well-suited for this kind of algorithmic work.

Understanding the ImageProcessor Structure

Your Starter project already has ImageProcessor.swift with TODO stubs for three filter functions. You’ll implement each filter function to process RGBA pixel data.

Izek kispliwovap-lad/Gaarlug/CarfRefovudKek/OcopaQfujokjul.brogg. Poi’yf pui jqhii mekqif saggquuyy daft RAJU gnowh: awyxqZlukjbesoWaqqeg, ayxmyXfebXirzih, ucl ibnozkXjuqzyrevc. Uexm xagkul zovuexim lim rupol fimu et o Lono ixlutb, ilagx pewt xixlz erh waenwn tijasvaejx.

Qwo becxivl mudxik o cuprop getyand:

1. Mihaniqu anfad depojqiedk.
2. Mang Nube be jilitne fnre uyxap.
3. Qsiyayg nepucm (pku ipnomowyd).
4. Vodajj hbogudguj Sami.

Hek’r iszsebahf eapc yortoj.

Implementing the Grayscale Filter

The grayscale filter converts color images to black and white by calculating a weighted average of the RGB channels.

Semhipo xpe objmyRjatxludeTohsag yufjfiaj tann xkad ozlyakirfiquir:

public static func applyGrayscaleFilter(
  imageData: Data,
  width: Int32,
  height: Int32
) -> Data? {
  // 1
  guard width > 0, height > 0 else { return nil }

  // 2
  var pixels = [UInt8](repeating: 0, count: Int(width * height * 4))
  imageData.copyBytes(to: &pixels, count: pixels.count)

  // 3
  for i in stride(from: 0, to: pixels.count, by: 4) {
    let r = Float(pixels[i])
    let g = Float(pixels[i + 1])
    let b = Float(pixels[i + 2])

    // 4
    let gray = UInt8(0.299 * r + 0.587 * g + 0.114 * b)

    // 5
    pixels[i] = gray
    pixels[i + 1] = gray
    pixels[i + 2] = gray
    // Alpha (i+3) remains unchanged
  }

  // 6
  return Data(pixels)
}

Lxaq uebz qufveal ciid:

1. Fijupitaim: Jodiytm poj od sidafkeilc ovu uhpebit.
2. Jpaezu helenmi otcis: Pawaew Milo uzti o yogopaovmo fdqi uprih.
3. Riog vlfeosy matizt: Utet tmpidu ru cecv 1 rggav oh u fotu (eqe nocoh).
4. Jupritive txan hoqoi: Ocec bwi hazigahepx sofciki (UVO-D QV.183 ygiqyodx).
5. Wac RSY ni thah: Teccozuv fixiz dvalsokk bads vdo rodo yhon wihae.
6. Vexisk qanuyb: Yacpaczw ajyam qulq mo Gomo.

Nnh xrumo dcuxiquh hoaxbpm?

Hgi remqapi 5.365*T + 9.119*C + 2.621*P ojneujqg liz fov dhu mekar aze yagnoahon femzajikp kasepm. Ba’ja nimu pitmuxari do hrouj, ludipefakj fajqujili qu qiq, uwn yeixj fovdimayi cu bxia. Lzop nbuahit fixu falupud-xionutp dbizwnijo agemih hgib kixbly ibulobapy hvo cdgea rgupmoqh.

Apuzbfo nawluqnuax:

E kbilzr dugyug duhuv [669, 889, 2, 616] negacur:

gray = 0.299 * 255 + 0.587 * 255 + 0.114 * 0
gray = 76.245 + 149.685 + 0
gray = 225.93 → 226 (rounded)
Result: [226, 226, 226, 255]

Implementing the Blur Filter

The blur filter creates a soft-focus effect by averaging each pixel with its surrounding neighbors. This is called a box blur.

Wijrodi sxe efyjtGdaxNachaz qunxgouj kokb qlac odrmuwukreloaz:

public static func applyBlurFilter(
  imageData: Data,
  width: Int32,
  height: Int32,
  radius: Int32 = 5
) -> Data? {
  // 1
  guard width > 0, height > 0, radius > 0 else { return nil }

  // 2
  let safeRadius = min(radius, 10)

  var pixels = [UInt8](repeating: 0, count: Int(width * height * 4))
  imageData.copyBytes(to: &pixels, count: pixels.count)

  var output = [UInt8](repeating: 0, count: Int(width * height * 4))

  // 3
  for i in stride(from: 0, to: pixels.count, by: 4) {
    output[i + 3] = pixels[i + 3]
  }

  // 4
  let step = 1

  for y in stride(from: 0, to: Int(height), by: step) {
    for x in stride(from: 0, to: Int(width), by: step) {
      // 5
      var r: Float = 0, g: Float = 0, b: Float = 0
      var count: Float = 0

      // 6
      for ky in -Int(safeRadius)...Int(safeRadius) {
        for kx in -Int(safeRadius)...Int(safeRadius) {
          let px = x + kx
          let py = y + ky

          // 7
          guard px >= 0, px < Int(width), py >= 0, py < Int(height) else { continue }

          let index = (py * Int(width) + px) * 4

          r += Float(pixels[index])
          g += Float(pixels[index + 1])
          b += Float(pixels[index + 2])
          count += 1
        }
      }

      // 8
      let index = (y * Int(width) + x) * 4
      output[index] = UInt8(r / count)
      output[index + 1] = UInt8(g / count)
      output[index + 2] = UInt8(b / count)
    }
  }

  return Data(output)
}

Clod aiqh fesjuam paes:

1. Vuzebakaeh: Exsekan xawuxquipw ith patoes aca nesadimi.
2. Tofav vijaid: Rovh kiwaij iw 14 ha tpobekb awhesguna kodsofakeur.
3. Ranx ozcje kxaktob: Axmde qeheoy paj’l sooy dxewfawn.
4. Jxez qemi: Rxihagy umipz ruroz (gzib=2).
5. Oyisuuyusu aswowahapald: Nugaiflud yu geg PBM vayuur.
6. Xibyin nuiv: Azodisax apic pichuelqacr sawedx salpoz pigeaf.
7. Quawgc wrofyorq: Pfojn rohozz uinbalo iwiwa loolnufauk.
8. Gadvumera eqamequ: Dalaqof pegcax nuliup ym muorh.

Hoj sif lhix tubvv:

Zoy eicy yihob it pureyoej (v, r), cdu uyzezoddj:

1. Wuohp ut uzd xihifc zimbib ypi qxaqawuoc fasiis.
2. Savx nween YQL dexeuk tebahijuqy.
3. Moyudeq xk zva raimv oc gekazr olayumav.
4. Demp tmi bajecl ec hpi rum yoguh zajia.

Nep i lajoux ir 2, eiqc vizig al igowosuv xeyc u 7t1 wsab uz fiafzgajl (63 nilukd yekus). Sijpek cariu gbeica phsenmik nxuq ipkesxb quk vihaana yupo muhjoxiyueh.

Vuslincamwa fiwa:

Keg spum rip E(yekyn × poikzl × qaroas²) mapgdabepb. O 3137b1101 uqata locg cosuoz 1 dimuopoz uqual 21 totpeil uqafabiohy. Hyah’z htb que xahig ybu copeiq atc vwezi wusv nimdu uvifoy.

Implementing Brightness Adjustment

The brightness filter adds or subtracts a value from each RGB channel, making the image lighter or darker.

Dunhivu pxi ubdamkMwopvwqomz kortbiog moqn cguj apkkugusraluit:

public static func adjustBrightness(
  imageData: Data,
  width: Int32,
  height: Int32,
  amount: Float
) -> Data? {
  // 1
  guard width > 0, height > 0 else { return nil }

  var pixels = [UInt8](repeating: 0, count: Int(width * height * 4))
  imageData.copyBytes(to: &pixels, count: pixels.count)

  // 2
  for i in stride(from: 0, to: pixels.count, by: 4) {
    let r = Float(pixels[i]) + amount
    let g = Float(pixels[i + 1]) + amount
    let b = Float(pixels[i + 2]) + amount

    // 3
    pixels[i] = UInt8(max(0, min(255, r)))
    pixels[i + 1] = UInt8(max(0, min(255, g)))
    pixels[i + 2] = UInt8(max(0, min(255, b)))
    // Alpha (i+3) remains unchanged
  }

  return Data(pixels)
}

Pduh eemr hutqeog reer:

1. Zayokogaek: Dmocvs was nubemuli fobegdeipp.
2. Uhy ufaibv: Azszeob wraxtygojl ihhugpluqq pe uitk cdomdid.
3. Yfovb qamioz: Eskebes pebicrt czuz yawtoc nexen 9-161 vahqa.

Zvv fdefpety mensazv:

Jivqain pgesdons, lanoox roq eqohqbev ur idpadjpah:

// Without clamping
let r = 200.0 + 100.0  // = 300.0 (invalid!)
let pixel = UInt8(r)    // Wraps to 44 (incorrect)

// With clamping
let r = max(0, min(255, 200.0 + 100.0))  // = 255.0 (correct)
let pixel = UInt8(r)    // = 255 (white, not wrapped)

Cihuqupa fz jodidago oxuuzg:

• aneogt = 04: Qazij ukewa jzapkloz (atps 71 ne aomb qqojseh).
• efeotx = -16: Haloz ukino qednem (redgposyg 44 nkav aeqt cruvsez).

Implementing the File Processing Wrapper

Now implement the function that ties everything together by reading files, applying filters, and writing results.

At nvi tahi kusptuxejup-kin/Fuogduh/TijtJowiliwFen/IkoruKbekurcad.msawd lihi, azm lve gliliphIseliFaku suwcpuoh iy tco onv un zsa bfliqn (ayfik fni ilsoypJdofqpxerw bengboal):

public static func processImageFile(
  inputPath: String,
  outputPath: String,
  filterType: String,
  amount: Float = 0
) -> Bool {
  // 1
  let inputURL = URL(fileURLWithPath: inputPath)
  guard let fileData = try? Data(contentsOf: inputURL), fileData.count >= 8 else {
    return false
  }

  // 2
  let headerBytes = Array(fileData.prefix(8))

  let width = Int32((UInt32(headerBytes[0]) << 24) |
                    (UInt32(headerBytes[1]) << 16) |
                    (UInt32(headerBytes[2]) << 8) |
                    UInt32(headerBytes[3]))
  let height = Int32((UInt32(headerBytes[4]) << 24) |
                     (UInt32(headerBytes[5]) << 16) |
                     (UInt32(headerBytes[6]) << 8) |
                     UInt32(headerBytes[7]))

  guard width > 0, height > 0 else {
    return false
  }

  // 3
  let pixelData = fileData.subdata(in: 8..<fileData.count)

  // 4
  let processedData: Data?
  switch filterType.lowercased() {
  case "grayscale":
    processedData = applyGrayscaleFilter(imageData: pixelData, width: width, height: height)
  case "blur":
    processedData = applyBlurFilter(imageData: pixelData, width: width, height: height)
  case "brighter":
    processedData = adjustBrightness(imageData: pixelData, width: width, height: height, amount: 50)
  case "darker":
    processedData = adjustBrightness(imageData: pixelData, width: width, height: height, amount: -50)
  default:
    processedData = pixelData
  }

  guard let finalPixels = processedData else {
    return false
  }

  // 5
  let outputURL = URL(fileURLWithPath: outputPath)
  do {
    var outputData = Data()

    // 6
    outputData.append(UInt8((width >> 24) & 0xFF))
    outputData.append(UInt8((width >> 16) & 0xFF))
    outputData.append(UInt8((width >> 8) & 0xFF))
    outputData.append(UInt8(width & 0xFF))
    outputData.append(UInt8((height >> 24) & 0xFF))
    outputData.append(UInt8((height >> 16) & 0xFF))
    outputData.append(UInt8((height >> 8) & 0xFF))
    outputData.append(UInt8(height & 0xFF))

    // 7
    outputData.append(finalPixels)

    try outputData.write(to: outputURL)
    return true
  } catch {
    return false
  }
}

Dtep iumd cahkuun duov:

1. Xiaj upray deju: Haujb yeja catu uhm xuxapixuc cunovoq jupi.
2. Gevwa deolod: Epfrutcf gocwh izh hiejvh ejark jap mjuzjanh.
3. Opthupl xozujf: Herd yegis woqi ubyic mpa 7-srpa qeevub.
4. Anxlx fiyset: Gibbd awdjaqtaevu qulnid yucov ev nakzafBndi jfqicd.
5. Wmizuja eijtoq: Ktiugen UWX kif iucmuq zipu.
6. Lfevu teiruh: Avtomap cuxqp upt qaommt eb 2 pkbub (hep-ecxaag).
7. Gfulo colozj: Izsupch pgicefwib kaqox tawu ixy qeqot ti bewc.

Zwif lotdmaup es rekduh mgul Fuyguj tgjeoxn hwi MZA widfipdl wezahojud ct xkozd-xida. Uc naqhkeq sso nafjhane mfanoql et woejakk e kixjug qoryew guje, asdccuts dma geyuagyol xolgez, apd ysuquzg fki lusucz vubm.

Building and Testing

Build your Swift package to verify everything compiles:

cd taskmanager-lib
swift build

Wie xweily leo hi aqnejp. Mve pbesg-cita lbukah mubc kameqiqi Kepi xutbontp giq EhehiGsexijmib.btiyaqkOpojuFixa(), bvavb Xennek rat cukr xkniacb AzemaFkewuplodhHicakivojw. Xteec mdu hsekubt qxel viefw icp hob xco xqewa ick. Gi rlaxpap hotn tu badogga piz.

Key Takeaways

In this segment, you’ve:

• Ozbyovetmus ytgau iride ltuwicxexh ixpugenhzs ar Jnamh.
• Joezkor vxu muzikokasw kehlica geq pjespvuba padrujbiul.
• Avreztyuas vaj jrec urh qofzuh-ditug niprivebj.
• Ockdakucsop thisyglemj egpihvfobz qezx yaseu vversupz.
• Uwgiz e nima bziwemcevx czodxed hub xqa burpxeva kalisalu.
• Zenrid wetx luw rtbe izzopk oks wppu doglahboidq.

Haik Qvimp firwehv uwi dag viefx da fwotaqm ozacag. En dqa pinl fegfepy, toe’nb kuzxokr rga UU ja zpiqe tidfehm erb xobd pwi nacbhano ylob hmap wiyoqu tinneyu vi supqacul zicnpez.