DEV Community: Thomas Dye

CCTV Storage Calculator

Thomas Dye — Sun, 13 Oct 2019 16:08:44 +0000

CCTV storage is getting pretty intense lately. With the introduction of higher resolution cameras, it's important to calculate the proper amount of storage to ensure the end user has enough record time.

Let's jump right into it!

So what factors do we need to calculate the storage?

// Total cameras
var totalCameras: Int = 0
// We'll get to cameraBitrate later
var cameraBitrate: Int = FrameSize.twoMegapixel.rawValue
// Total days
var totalDays: Int = 30
// Total hours per day
var totalHours: Int = 24
// Storage in GB in-case we are below 1000GB (1TB)
var storageGB: Double = 0.0
// Storage in TB in-case we are above 1000GB (1TB)
var storageTB: Double = 0.0
// Compression will refer to H.264 or H.265. We'll also get to this later
var compression: Double = CompressionMethod.h264.rawValue
// Frames per second
var framesPerSecond: Int = 7

Awesome! Now let's get back to the cameraBitrate. For this, let's create an enum to grab different values based on the current selected camera bitrate.

enum FrameSize: Int {
   case twoMegapixel = 20
   case threeMegapixel = 26
   case fourMegapixel = 36
   case fiveMegapixel = 46
   case eightMegapixel = 72
}

These values are the size of each frame for each megapixel. We'll multiply the selected megapixel by the framesPerSecond to get the total storage per second. Once we have that number, we can simply multiply it by 3,600 to get our total storage per hour in GB.

// Example: 7 (FPS) * 50KB (twoMegapixel) = 350KB/s
let totalFrameSizePerSecond = (framesPerSecond * cameraBitrate)      
// Example: 350KB/s * 3600 (seconds/hour) = 1_260_000KB/hr
let totalSizePerHour = totalFrameSizePerSecond * convertSecondsToHour

Now that we have our total storage size per hour, let's multiple that number by the total number of cameras to get our total storage per day

storageGB = totalSizePerHour * totalCameras

Sweet! Now we have our total size per hour for the total number of cameras. Now we need to multiply that number by the number of recording hours (totalHours). Some systems do not require recording 24 hours per day. So we'll use totalHours given to us by the user to calculate storage according to their needs. We could simply add this to the original storageGB calculation above, but I wanted to break it out to explain.

storageGB = storageGB * totalHours

The last calculation we need to make before determining whether we will display GB or TB is the compression method. In the CCTV world, there are a few compression methods available. For this instance we will stick with the main two: H.264 & H.265. Our calculation so far has been based on H.264, so if we determine the user is utilizing H.264, we will simply display the storage already calculated. On the other hand, if the user is utilizing H.265, we will need to recalculate the total based on that compression method. H.265 compression saves storage by roughly 30%, so our calculation isn't too difficult.

For this, let's create a simple enum to make life easier.

enum CompressionMethod: Double {
   case h264 = 1.0
   case h265 = 1.3
}

Now, we can write a simple if statement to determine the storageGB based on the users compression method.

if compression == CompressionMethod.h265 {
   storageGB = storageGB * CompressionMethod.h265.rawValue
} else {
   storageGB = storageGB * CompressionMethod.h264.rawValue
}

Now that we have our storage in GB with all variable calculated, let's determine if we need to convert to TB or not using a simple if statement.

if storageGB > 1000 {
   storageTB = storageGB / 1000
}

That's it! We've calculated total storage for our CCTV system using some simple calculations.

Thanks for reading!

Vocabulary Words

Thomas Dye — Thu, 25 Jul 2019 04:42:03 +0000

Swift Vocabulary

thomasdye / SwiftVocabulary

SwiftVocabulary

Click on a cell to segue to it's Definition View Controller

Click Add Word at the bottom to submit a word, definition, and example

Swipe left to delete a cell

View on GitHub

Let's make an example struct

struct VocabularyWord {
    let word: String
    let definition: String
    let example: String
}

Now let's make an array using the VocabularyWord type

    var vocabWords: [VocabularyWord] = [VocabularyWord(word: "word1", definition: "definition1", example: "example1"), VocabularyWord(word: "word2", definition: "definition2", example: "example2")]

Now we need to add them to their cells

    override func numberOfSections(in tableView: UITableView) -> Int {

        return 1
    }

    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {

        return vocabWords.count
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "ReuseIdentifier", for: indexPath)

        let word = vocabWords[indexPath.row]
        cell.textLabel?.text = word.word
        return cell
    }

Now we can make the link from the cell to the Definition View

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == NameOfSegueHere" {

            guard let indexPath = tableView.indexPathForSelectedRow,
                let definitionVC = segue.destination as? ViewControllerNameHere else { return }

            let cellWord = vocabWords[indexPath.row]

            definitionVC.cellWord = cellWord

        }
    }

We can also add this cool feature to delete unwanted items

    override func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
        if editingStyle == UITableViewCell.EditingStyle.delete {
            vocabWords.remove(at: indexPath.row)
            tableView.deleteRows(at: [indexPath], with: UITableView.RowAnimation.automatic)
        }

    }

Navigation Controller Practice

Thomas Dye — Wed, 24 Jul 2019 04:13:09 +0000

thomasdye / Rainbow

Rainbow

This project was intended to help better understand the navigation controller

Feel free to clone and check it out for yourself. This is a good building ground for learning how to make an app with multiple pages.

View on GitHub

This is where we will create our array of colors using [MyColor] as the type to return numberOfRowsInSection as colors.count (this .count is referring to each color we will store in the var colors)

import UIKit

class ColorsTableViewController: UITableViewController {

    var colors: [MyColor] = [MyColor(name: "Red", color: .red),
                             MyColor(name: "Orange", color: .orange),
                             MyColor(name: "Yellow", color: .yellow),
                             MyColor(name: "Green", color: .green),
                             MyColor(name: "Blue", color: .blue),
                             MyColor(name: "Cyan", color: .cyan),
                             MyColor(name: "Purple", color: .purple)]

    override func viewDidLoad() {
        super.viewDidLoad()

    }

    // MARK: - Table view data source

    override func numberOfSections(in tableView: UITableView) -> Int {
        // #warning Incomplete implementation, return the number of sections

        return 1
    }

    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        // #warning Incomplete implementation, return the number of rows
        return colors.count
    }

Under cellForRowAt, we want to replace "ReuseIdentifier" with something unique that relates to our project. For this instance, we'll use "ColorCell", but that leaves us with one problem. We need to set our new identifier to the same value of ColorCell. This is found by selecting the prototype cell on your Main.storyboard file, selecting the 'attributes inspector' and setting the identifier to ColorCell.

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "ColorCell", for: indexPath)

        let color = colors[indexPath.row]

        cell.textLabel?.text = color.name

        return cell
    }

    // MARK: - Navigation

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {

        if segue.identifier == "ShowColorSegue" {

            guard let indexPath = tableView.indexPathForSelectedRow,
                let colorDetailVC = segue.destination as? ColorDetailViewController else { return }

            let cellColor = colors[indexPath.row]

            colorDetailVC.cellColor = cellColor

        }
    }
}

My first app

Thomas Dye — Tue, 23 Jul 2019 03:03:27 +0000

This is the first app I have ever built, and it feels good.

CalculatorViewController.swift

import UIKit

class CalculatorViewController: UIViewController {

    @IBOutlet weak var decimalButton: UIButton!

    @IBOutlet weak var subtractButton: UIButton!

    @IBOutlet weak var divideButton: UIButton!

    @IBOutlet weak var addButton: UIButton!

    @IBOutlet weak var multiplyButton: UIButton!

    @IBOutlet weak var equalsButton: UIButton!

    @IBOutlet weak var outputLabel: UILabel!

    @IBOutlet weak var clearButton: UIButton!

    @IBOutlet weak var previousAnswerLabel: UILabel!

    @IBOutlet weak var previousAnswerTitle: UILabel!

    @IBOutlet weak var copyButton: UIButton!

    var brain: CalculatorBrain?
    let xYValue = 0.75
    let durationTime = 0.15

    override func viewDidLoad() {
        super.viewDidLoad()
        previousAnswerLabel.text = nil
        previousAnswerTitle.text = nil
        brain = CalculatorBrain()
    }

    // MARK: - Action Handlers

    @IBAction func operandTapped(_ sender: UIButton) {
        UIButton.animate(withDuration: durationTime,
                         animations: {
                            sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))
        },
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })
        // Takes in the value of the operand tapped
        if let operandTapped = sender.titleLabel?.text {

            let buttonDoesntContainDecimal = !operandTapped.contains(".")
            let buttonContainsDecimalWithNoCurrentDecimal = operandTapped.contains(".") && !(outputLabel.text?.contains(".") ?? false)

            if buttonDoesntContainDecimal || buttonContainsDecimalWithNoCurrentDecimal {
                outputLabel.text = brain?.addOperandDigit(operandTapped)
            }
        }
    }

    @IBAction func operatorTapped(_ sender: UIButton) {
        UIButton.animate(withDuration: durationTime,
                         animations: { sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))},
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })
        // Takes in the value of the operator tapped
        if let operatorValueTapped = sender.titleLabel?.text {

            brain?.setOperator(operatorValueTapped)

        }
    }

    @IBAction func equalTapped(_ sender: UIButton) {
        UIButton.animate(withDuration: durationTime,
                         animations: {
                            sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))
        },
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })
        // Calculates the answer and sets it to the value 'answer'
        if let answer = brain!.calculateIfPossible() {
            copyButton.setTitleColor(.green, for: .normal)
            previousAnswerLabel.text = answer
            previousAnswerTitle.text = "Previous Answer"
            outputLabel.text = answer

        }


    }

    @IBAction func clearTapped(_ sender: UIButton) {
        UIButton.animate(withDuration: durationTime,
                         animations: {
                            sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))
        },
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })
        // Clears the calculation when tapped

        if outputLabel.text == "0" {
            clearTransaction()
            copyButton.setTitleColor(.black, for: .normal)
            previousAnswerTitle.text = nil
            previousAnswerLabel.text = nil
        }

        clearTransaction()
        outputLabel.text = "0"
    }

    // MARK: - Private

    private func clearTransaction() {

        // Clear calculation function
        brain = CalculatorBrain()

    }

    @IBAction func posNegButtonTapped(_ sender: UIButton) {
        UIButton.animate(withDuration: durationTime,
                         animations: {
                            sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))
        },
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })

        // Turns number negative or positive
        if var posNegNumber = Double(outputLabel.text ?? "") {
            posNegNumber = posNegNumber * -1.0
            outputLabel.text = String(posNegNumber)
            brain?.operand1String = String(posNegNumber)

        }
    }

    @IBAction func percentButtonTapped(_ sender: UIButton) {

        UIButton.animate(withDuration: durationTime,
                         animations: {
                            sender.transform = CGAffineTransform(scaleX: CGFloat(self.xYValue), y: CGFloat(self.xYValue))
        },
                         completion: { finish in
                            UIButton.animate(withDuration: self.durationTime, animations: {
                                sender.transform = CGAffineTransform.identity
                            })
        })
        // Divides by 100.0 (Double) to return the percentageNumber
        if var percentageNumber = Double(outputLabel.text ?? "") {
            percentageNumber = percentageNumber / 100.0
            outputLabel.text = String(percentageNumber)
            brain?.operand1String = String(percentageNumber)

        }
    }

    @IBAction func subtractButtonPressed(_ sender: Any) {

        // Set color for button pressed
        subtractButton.backgroundColor = .white
        subtractButton.setTitleColor(.black, for: .normal)

        // Set default colors back
        divideButton.backgroundColor = .green
        divideButton.setTitleColor(.white, for: .normal)
        multiplyButton.backgroundColor = .green
        multiplyButton.setTitleColor(.white, for: .normal)
        addButton.backgroundColor = .green
        addButton.setTitleColor(.white, for: .normal)
        equalsButton.backgroundColor = .green
        equalsButton.setTitleColor(.white, for: .normal)

    }

    @IBAction func divideButtonPressed(_ sender: Any) {

        // Set color for button pressed
        divideButton.backgroundColor = .white
        divideButton.setTitleColor(.black, for: .normal)

        // Set default colors back
        subtractButton.backgroundColor = .green
        subtractButton.setTitleColor(.white, for: .normal)
        multiplyButton.backgroundColor = .green
        multiplyButton.setTitleColor(.white, for: .normal)
        addButton.backgroundColor = .green
        addButton.setTitleColor(.white, for: .normal)
        equalsButton.backgroundColor = .green
        equalsButton.setTitleColor(.white, for: .normal)
    }

    @IBAction func multiplyButtonPressed(_ sender: Any) {

        // Set color for button pressed
        multiplyButton.backgroundColor = .white
        multiplyButton.setTitleColor(.black, for: .normal)

        // Set default colors back
        subtractButton.backgroundColor = .green
        subtractButton.setTitleColor(.white, for: .normal)
        divideButton.backgroundColor = .green
        divideButton.setTitleColor(.white, for: .normal)
        addButton.backgroundColor = .green
        addButton.setTitleColor(.white, for: .normal)
        equalsButton.backgroundColor = .green
        equalsButton.setTitleColor(.white, for: .normal)
    }

    @IBAction func addButtonPressed(_ sender: Any) {

        // Set color for button pressed
        addButton.backgroundColor = .white
        addButton.setTitleColor(.black, for: .normal)

        // Set default colors back
        subtractButton.backgroundColor = .green
        subtractButton.setTitleColor(.white, for: .normal)
        multiplyButton.backgroundColor = .green
        multiplyButton.setTitleColor(.white, for: .normal)
        divideButton.backgroundColor = .green
        divideButton.setTitleColor(.white, for: .normal)
        equalsButton.backgroundColor = .green
        equalsButton.setTitleColor(.white, for: .normal)
    }

    @IBAction func equalButtonPressed(_ sender: Any) {

        // Set color for button pressed
        equalsButton.backgroundColor = .white
        equalsButton.setTitleColor(.black, for: .normal)

        // Set default colors back
        subtractButton.backgroundColor = .green
        subtractButton.setTitleColor(.white, for: .normal)
        multiplyButton.backgroundColor = .green
        multiplyButton.setTitleColor(.white, for: .normal)
        addButton.backgroundColor = .green
        addButton.setTitleColor(.white, for: .normal)
        divideButton.backgroundColor = .green
        divideButton.setTitleColor(.white, for: .normal)
    }


    @IBAction func clearButtonPressed(_ sender: Any) {

        // Default all colors when clear button pressed
        equalsButton.backgroundColor = .green
        equalsButton.setTitleColor(.white, for: .normal)
        subtractButton.backgroundColor = .green
        subtractButton.setTitleColor(.white, for: .normal)
        multiplyButton.backgroundColor = .green
        multiplyButton.setTitleColor(.white, for: .normal)
        addButton.backgroundColor = .green
        addButton.setTitleColor(.white, for: .normal)
        divideButton.backgroundColor = .green
        divideButton.setTitleColor(.white, for: .normal)
    }

    @IBAction func copyButtonPressed(_ sender: Any) {
        outputLabel.text = previousAnswerLabel.text
        brain?.operand1String = previousAnswerLabel.text ?? ""
    }

}

CalculatorBrain.swift

import Foundation

enum OperatorType: String {
    case addition = "+"
    case subtraction = "−"
    case multiplication = "×"
    case division = "÷"
}

class CalculatorBrain {
    var operand1String = ""
    var operand2String = ""
    var operatorType: OperatorType?

    func addOperandDigit(_ digit: String) -> String {

        // Adds operand digit if nil
        if operatorType != nil {
            operand2String.append(digit)
            return operand2String
        } else {
            operand1String.append(digit)
            return operand1String
        }
    }

    func setOperator(_ operatorString: String) {

        // Sets the operator to it's rawValue
        operatorType = OperatorType(rawValue: operatorString)

    }

    func calculateIfPossible() -> String? {

        // Calculation for .addition, .subtraction, .multiplication, . division
                // Checking to see if oprand1String or operand2String are empty
        let numberFormatting = NumberFormatter()
        numberFormatting.usesGroupingSeparator = true
        numberFormatting.numberStyle = .decimal
        numberFormatting.locale = Locale.current

        if operand1String.isEmpty, operand2String.isEmpty, operatorType == nil {
            return "0"
        } else {
            var finalAnswer: String

            if let firstOperandNumber = Double(operand1String), let secondOperandNumber = Double(operand2String) {

                switch operatorType {
                case .addition? :
                    finalAnswer = String(firstOperandNumber + secondOperandNumber)
                case .subtraction? :
                    finalAnswer = String(firstOperandNumber - secondOperandNumber)
                case .multiplication? :
                    finalAnswer = String(firstOperandNumber * secondOperandNumber)
                case .division? :
                    if secondOperandNumber == 0 {
                        return "Nice try ;)"
                    } else {
                        finalAnswer = String(firstOperandNumber / secondOperandNumber)
                    }
                default :
                    return nil
                }

            } else {
                return nil

            }

            operand1String = finalAnswer
            operand2String = ""
            return finalAnswer
        }
    }

}