Additional calculators, v3.1

.eslintignore

@@ -1,2 +1 @@
 node_modules
-gui

.github/dependabot.yml

@@ -11,7 +11,7 @@ updates:
     interval: daily
   open-pull-requests-limit: 5
 - package-ecosystem: npm
-  directory: "/package"
+  directory: "/module"
   schedule:
     interval: daily
   open-pull-requests-limit: 5

.github/workflows/publish-npm-github-packages.yml

@@ -32,8 +32,8 @@ jobs:
           node-version: "24.x"
           registry-url: "https://registry.npmjs.org"
       - run: yarn install
-      - run: yarn --cwd package build
-      - run: yarn --cwd package publish
+      - run: yarn --cwd module build
+      - run: yarn --cwd module publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
 
@@ -50,7 +50,7 @@ jobs:
           node-version: "24.x"
           registry-url: https://npm.pkg.github.com/
       - run: yarn install
-      - run: yarn --cwd package build
-      - run: yarn --cwd package publish
+      - run: yarn --cwd module build
+      - run: yarn --cwd module publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_PUBLISH_TOKEN}}

.gitignore

@@ -1,4 +1,4 @@
-package/coverage/
+module/coverage/
 dist/
 node_modules/
 yarn-error.log

app/index.d.ts

@@ -16,7 +16,7 @@ interface LensInputs {
 }
 
 interface LensDefinition extends LensInputs {
-    depthOfField: import('dof').DepthOfFieldDetails
+    depthOfField: import('../module/dist').DepthOfFieldDetails
 }
 
 type DefaultLensData = Pick<LensDefinition, 'name' | 'focalLength' | 'aperture' | 'sensorKey'>

app/src/store/lensSlice.ts

@@ -1,4 +1,4 @@
-import { Lens } from 'dof'
+import { Lens } from '../../../module/dist'
 import { compact, defaults } from 'lodash'
 import { StateCreator } from 'zustand'
 import areDuplicateLenses from '../utilities/areDuplicateLenses'

app/src/ui/Graph/useData.ts

@@ -1,7 +1,7 @@
 import { LineSeries } from '@nivo/line'
-import { Lens } from 'dof'
 import { compact } from 'lodash'
 import { useMemo } from 'react'
+import { Lens } from '../../../../package/dist/Lens'
 import useDoFStore from '../../store'
 import sensorList from '../../utilities/sensorList'
 import useIsMobile from '../../utilities/useIsMobile'

app/src/ui/LensTable/Table/Row/Aperture.tsx

@@ -1,5 +1,5 @@
 import { FormControl, InputLabel, MenuItem, Select, SelectChangeEvent } from '@mui/material'
-import { apertureMap } from 'dof'
+import { apertureMap } from '../../../../../../module/dist'
 import useDoFStore from '../../../../store'
 import useIsMobile from '../../../../utilities/useIsMobile'
 

app/src/utilities/sensorList.ts

@@ -30,9 +30,11 @@ const fullList = {
         name: '1" CCD, Nikon CX, Sony RX100',
         value: 2.72,
     },
-    iPhone14: {
-        name: 'iPhone 14 (2022)',
-        value: 2.86, // 9.8x7.3mm, or 71.54mm^2
+    iPhone14Pro: {
+        name: 'iPhone 14 Pro (2022)',
+        // https://www.dpreview.com/articles/6110937480
+        // 48MP Type 1/1.28 (9.8x7.3mm, or 71.54mm^2)
+        value: 2.86,
         isCommon: true,
     },
     BlackmagicCC: {

app/src/utilities/useReadFromHash.ts

@@ -1,4 +1,4 @@
-import { isApertureString } from 'dof'
+import { isApertureString } from '../../../module/dist'
 import { compact } from 'lodash'
 import { useEffect, useState } from 'react'
 import useDoFStore from '../store'

package/package.json → module/package.json

@@ -1,7 +1,7 @@
 {
     "name": "dof",
     "description": "Depth-of-field calculator for comparing camera lenses",
-    "version": "3.0.0",
+    "version": "3.1.0",
     "repository": {
         "type": "git",
         "url": "https://github.com/patik/dof.git"

package/src/Lens.ts → module/src/Lens.ts

@@ -1,5 +1,5 @@
+import { calculateDepthOfField } from './calculators/calculateDepthOfField'
 import { combineSettings } from './utilities/combineSettings'
-import { calculateDepthOfField } from './utilities/calculateDepthOfField'
 
 export const builtInDefaults: DefaultOptions = Object.freeze({
     focalLength: 35,
@@ -45,6 +45,12 @@ export class Lens {
             distance = imperialUnits ? defaultDistanceImperial : defaultDistanceMetric
         }
 
-        return calculateDepthOfField(this.focalLength, this.aperture, this.cropFactor, distance, imperialUnits)
+        return calculateDepthOfField({
+            focalLength: this.focalLength,
+            aperture: this.aperture,
+            cropFactor: this.cropFactor,
+            distance,
+            imperialUnits,
+        })
     }
 }

module/src/calculators/calculateAperture.test.ts

@@ -0,0 +1,86 @@
+import { calculateAperture } from './calculateAperture'
+
+describe('Calculating the depth of field with calculateAperture()', () => {
+    describe('metric units (meters)', () => {
+        test('DoF 2.6 meters, 35mm, f/2, crop factor of 1, 5 meters', () => {
+            const result = calculateAperture({
+                focalLength: 35,
+                cropFactor: 1,
+                distance: 5,
+                dof: 2.584690961719362,
+                near: 4.021931840567339,
+                imperialUnits: false,
+            })
+
+            expect(result.aperture).toBe(2)
+        })
+
+        test('DoF 11 meters, 50mm, f/1.4, crop factor of 2, 25 meters', () => {
+            const result = calculateAperture({
+                focalLength: 50,
+                cropFactor: 2,
+                distance: 25,
+                dof: 11.082093523926748,
+                near: 20.63203625607849,
+                imperialUnits: false,
+            })
+
+            expect(result.aperture).toBe(1.4142139999999992)
+        })
+
+        test('DoF 7.9 meters, 28mm, f/5, crop factor of 3.02, 7 meters', () => {
+            // Blackmagic Cine Cam sensor
+            const result = calculateAperture({
+                focalLength: 28,
+                cropFactor: 3.02,
+                distance: 7,
+                dof: 7.851429380291624,
+                near: 4.833680315786585,
+                imperialUnits: false,
+            })
+
+            expect(result.aperture).toBe(5.039684)
+        })
+
+        test('such that the far end of the range is infinity', () => {
+            const result = calculateAperture({
+                focalLength: 24,
+                cropFactor: 1,
+                distance: 5,
+                dof: Infinity,
+                near: 0.9715025906735751,
+                imperialUnits: false,
+            })
+
+            expect(result.aperture).toBe(NaN)
+        })
+    })
+
+    describe('imperial units (feet)', () => {
+        test('DoF 7 feet, 35mm, f/2, crop factor of 1, 15 feet', () => {
+            const result = calculateAperture({
+                focalLength: 35,
+                cropFactor: 1,
+                distance: 15,
+                dof: 7.012923816256398,
+                near: 12.27274548830499,
+                imperialUnits: true,
+            })
+
+            expect(result.aperture).toBe(2.000000000000001)
+        })
+
+        test('DoF 12.6 feet, 55mm, f/3.2, crop factor of 2.7, 42 feet', () => {
+            const result = calculateAperture({
+                focalLength: 55,
+                cropFactor: 2.7,
+                distance: 42,
+                dof: 12.634717336600715,
+                near: 36.61227928000945,
+                imperialUnits: true,
+            })
+
+            expect(result.aperture).toBe(3.1748020000000055)
+        })
+    })
+})

module/src/calculators/calculateAperture.ts

@@ -0,0 +1,38 @@
+import { getApertureName } from '../utilities/aperture'
+import { toMillimeters } from '../utilities/units'
+
+/**
+ * Returns the aperture for a given lens' attributes and depth of field
+ */
+export function calculateAperture({
+    focalLength,
+    cropFactor,
+    distance,
+    dof,
+    near,
+    imperialUnits,
+}: {
+    focalLength: number
+    cropFactor: number
+    distance: number
+    dof: number
+    near: number
+    imperialUnits?: boolean
+}): ApertureResult {
+    const mmDist = toMillimeters(distance, imperialUnits)
+    const mmDof = toMillimeters(dof, imperialUnits)
+    const mmNear = toMillimeters(near, imperialUnits)
+
+    const mmFar = mmNear + mmDof
+    const mmHF = (-1 * mmDist * focalLength + mmDist * mmFar) / (-1 * mmDist + mmFar)
+    const cropMultiplier = 1 / cropFactor
+    const coc = Math.round(0.03 * cropMultiplier * 1000) / 1000
+    const aperture = Math.pow(focalLength, 2) / (coc * mmHF - coc * focalLength)
+
+    const result: ApertureResult = {
+        aperture,
+        fStop: getApertureName(aperture),
+    }
+
+    return result
+}

module/src/calculators/calculateCropFactor.test.ts

@@ -0,0 +1,73 @@
+import { calculateCropFactor } from './calculateCropFactor'
+
+describe('Calculating the depth of field with calculateCropFactor()', () => {
+    describe('metric units (meters)', () => {
+        test('35mm, f/2, crop factor of 1, 5 meters', () => {
+            const result = calculateCropFactor({
+                dof: 2.584690961719362,
+                near: 4.021931840567339,
+                focalLength: 35,
+                aperture: 2,
+                distance: 5,
+                imperialUnits: false,
+            })
+
+            expect(result.cropFactor).toBe(1)
+        })
+
+        test('50mm, f/1.4, crop factor of 2, 25 meters', () => {
+            const result = calculateCropFactor({
+                dof: 11.082093523926748,
+                near: 20.63203625607849,
+                focalLength: 50,
+                aperture: 1.414214,
+                distance: 25,
+                imperialUnits: false,
+            })
+
+            expect(result.cropFactor).toBe(2)
+        })
+
+        test('28mm, f/5, crop factor of 3.02, 7 meters', () => {
+            // Blackmagic Cine Cam sensor
+            const result = calculateCropFactor({
+                focalLength: 28,
+                aperture: 5.039684,
+                dof: 7.851429380291624,
+                near: 4.833680315786585,
+                distance: 7,
+                imperialUnits: false,
+            })
+
+            expect(result.cropFactor).toBe(3)
+        })
+    })
+
+    describe('imperial units (feet)', () => {
+        test('35mm, f/2, crop factor of 1, 15 feet', () => {
+            const result = calculateCropFactor({
+                focalLength: 35,
+                aperture: 2,
+                near: 12.27274548830499,
+                dof: 7.012923816256398,
+                distance: 15,
+                imperialUnits: true,
+            })
+
+            expect(result.cropFactor).toBe(1)
+        })
+
+        test('55mm, f/3.2, crop factor of 2.7, 42 feet', () => {
+            const result = calculateCropFactor({
+                focalLength: 55,
+                aperture: 3.174802,
+                dof: 12.634717336600715,
+                near: 36.61227928000945,
+                distance: 42,
+                imperialUnits: true,
+            })
+
+            expect(result.cropFactor).toBe(2.727)
+        })
+    })
+})

module/src/calculators/calculateCropFactor.ts

@@ -0,0 +1,32 @@
+import { toMillimeters } from '../utilities/units'
+
+/**
+ * Returns the depth of field characteristics for a given lens' attributes
+ */
+export function calculateCropFactor({
+    near,
+    dof,
+    focalLength,
+    aperture,
+    distance,
+    imperialUnits,
+}: {
+    near: number
+    dof: number
+    focalLength: number
+    aperture: number
+    distance: number
+    imperialUnits: boolean
+}): CropFactorResult {
+    const mmDist = toMillimeters(distance, imperialUnits)
+    const mmDof = toMillimeters(dof, imperialUnits)
+    const mmNear = toMillimeters(near, imperialUnits)
+
+    const mmFar = mmNear + mmDof
+    const mmHF = (-1 * mmDist * focalLength + mmDist * mmFar) / (-1 * mmDist + mmFar)
+    const coc = Math.pow(focalLength, 2) / (aperture * mmHF - aperture * focalLength)
+    const cropMultiplier = (100 * coc) / 3
+    const cropFactor = Math.round((1 / cropMultiplier) * 1000) / 1000
+
+    return { cropFactor }
+}