@things-factory/spc 8.0.0-beta.8 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/spc",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,11 +27,11 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@operato/dataset": "^8.0.0-beta",
-    "@operato/form": "^8.0.0-beta",
-    "@operato/spc": "^8.0.0-beta",
-    "@things-factory/dataset": "^8.0.0-beta.8",
-    "@things-factory/shell": "^8.0.0-beta.5"
+    "@operato/dataset": "^8.0.0",
+    "@operato/form": "^8.0.0",
+    "@operato/spc": "^8.0.0",
+    "@things-factory/dataset": "^8.0.0",
+    "@things-factory/shell": "^8.0.0"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controllers/data-use-case-spc.ts

@@ -0,0 +1,44 @@
+import { DataItemSpecSet, DataUseCase, EvaluationResult } from '@things-factory/dataset'
+
+export class DataUseCaseSPC implements DataUseCase {
+  getSpecification(): DataItemSpecSet {
+    return {
+      name: 'SPC',
+      description: 'Statistical Process Control Data Spec',
+      help: '',
+      specs: [
+        {
+          type: 'spc-limits' /* 'A value which seperates acceptability from unacceptability' */,
+          label: 'control limits',
+          name: 'controlLimits'
+        }
+      ]
+    }
+  }
+
+  evaluate(spec: any, values: any | any[]): EvaluationResult {
+    const { minimum, maximum, acceptables } = spec['controlLimits']
+
+    if (!(values instanceof Array)) {
+      values = [values]
+    }
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i]
+
+      if (minimum != null && value < minimum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (maximum != null && value > maximum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (acceptables != null && !acceptables.includes(value)) {
+        return { oos: true, ooc: true }
+      }
+    }
+
+    return { oos: false, ooc: false }
+  }
+}

package/server/controllers/index.ts

@@ -0,0 +1 @@
+export * from './data-use-case-spc'

package/server/controllers/rules/cp-cpk.ts

@@ -0,0 +1,29 @@
+import { SPCChartPlot } from '../../service/spc-chart/spc-chart-type'
+
+interface ProcessCapabilityAnalysis {
+  cp: number
+  cpk: number
+}
+
+function calculateProcessCapability(plots: SPCChartPlot[], USL: number, LSL: number): ProcessCapabilityAnalysis {
+  // 전체 평균 계산
+  const overallMean = plots.reduce((sum, plot) => sum + plot.xbar, 0) / plots.length
+
+  // 전체 표준 편차 계산
+  let allValues = plots.flatMap(plot => plot.values)
+  const meanOfAllValues = allValues.reduce((sum, value) => sum + value, 0) / allValues.length
+  const squaredDiffs = allValues.map(value => Math.pow(value - meanOfAllValues, 2))
+  const variance = squaredDiffs.reduce((sum, diff) => sum + diff, 0) / (allValues.length - 1)
+  const stdDeviation = Math.sqrt(variance)
+
+  // CP 계산
+  const cp = (USL - LSL) / (6 * stdDeviation)
+
+  // CPK 계산
+  const cpk = Math.min((USL - overallMean) / (3 * stdDeviation), (overallMean - LSL) / (3 * stdDeviation))
+
+  return {
+    cp,
+    cpk
+  }
+}

package/server/controllers/spc-chart/c.ts

@@ -0,0 +1,31 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateCChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    defects: plot.values.map(Boolean).length,
+    n: plot.values.length
+  }))
+
+  // 총 결함 수를 계산합니다.
+  const totalDefects = plots.reduce((sum, { defects }) => sum + defects, 0)
+
+  // 평균 결함 수(C-bar)를 계산합니다.
+  const cl = totalDefects / plots.length
+
+  // 상한 제어선(UCL)과 하한 제어선(LCL)을 계산합니다.
+  // 포아송 분포를 가정할 때, UCL = C-bar + 3*sqrt(C-bar), LCL = C-bar - 3*sqrt(C-bar) (단, LCL이 음수인 경우 0으로 설정)
+  const ucl = cl + 3 * Math.sqrt(cl)
+  const lcl = Math.max(cl - 3 * Math.sqrt(cl), 0)
+
+  return {
+    chartType: 'C',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/histogram.ts

@@ -0,0 +1,38 @@
+interface HistogramSample {
+  value: number
+}
+
+interface HistogramBin {
+  binRange: string // 구간을 나타내는 문자열, 예: "0-1"
+  count: number // 해당 구간에 속하는 데이터의 개수
+}
+
+interface HistogramResult {
+  chartType: 'Histogram'
+  bins: HistogramBin[] // 히스토그램의 각 구간과 해당 구간의 데이터 개수
+}
+
+export function calculateHistogram(samples: HistogramSample[], numBins: number): HistogramResult {
+  const values = samples.map(sample => sample.value)
+  const minValue = Math.min(...values)
+  const maxValue = Math.max(...values)
+  const range = maxValue - minValue
+  const binWidth = range / numBins
+
+  // 초기화된 구간 배열 생성
+  const bins: HistogramBin[] = Array.from({ length: numBins }, (_, i) => ({
+    binRange: `${(minValue + i * binWidth).toFixed(2)}-${(minValue + (i + 1) * binWidth).toFixed(2)}`,
+    count: 0
+  }))
+
+  // 각 샘플을 적절한 구간에 할당하고 개수를 세어 구간의 개수를 업데이트합니다.
+  samples.forEach(sample => {
+    const binIndex = Math.min(numBins - 1, Math.floor((sample.value - minValue) / binWidth))
+    bins[binIndex].count++
+  })
+
+  return {
+    chartType: 'Histogram',
+    bins
+  }
+}

package/server/controllers/spc-chart/i.ts

@@ -0,0 +1,31 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateIChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map((plot, index) => ({
+    ...plot,
+    i: plot.values[0],
+    mr: index == 0 ? 0 : Math.abs(plot.values[0] - plots[index - 1].values[0])
+  }))
+
+  // 개별 측정값의 평균을 계산하여 중심선(cl)을 구합니다.
+  const cl = plots.reduce((acc, plot) => acc + plot.values[0], 0) / plots.length
+
+  // 개별 측정값의 표준편차를 계산합니다.
+  const standardDeviation = Math.sqrt(plots.reduce((acc, plot) => acc + Math.pow(plot.values[0] - cl, 2), 0) / plots.length)
+
+  // 공정 변동을 고려하여 상한 제어선(ucl)과 하한 제어선(lcl)을 계산합니다.
+  // 여기서는 3시그마(3 * 표준편차)를 사용합니다. 상황에 따라 적절한 시그마 수준을 조정할 수 있습니다.
+  const ucl = cl + 3 * standardDeviation
+  const lcl = cl - 3 * standardDeviation
+
+  return {
+    chartType: 'I',
+    controlLimits: {
+      cl,
+      ucl,
+      lcl
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/index.ts

@@ -0,0 +1,171 @@
+const result = {
+  dataset: {
+    id: 'aaa',
+    name: 'bbb'
+  },
+  query: {},
+  analysisResults: [
+    {
+      chartType: 'Xbar',
+      variables: [
+        {
+          name: 'variable1',
+          stats: {
+            mean: 22,
+            UCL: 25,
+            LCL: 19,
+            CL: 22
+          },
+          samples: [
+            { x: '1', values: 22 },
+            { x: '2', values: 23 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'R',
+      variables: [
+        {
+          name: 'variable2',
+          stats: {
+            range: 1.3,
+            UCL: 2.1,
+            LCL: 0.5,
+            CL: 1.3
+          },
+          samples: [
+            { x: '1', value: 1.2 },
+            { x: '2', value: 1.3 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'p',
+      variables: [
+        {
+          name: 'variable3',
+          stats: {
+            proportion: 0.05,
+            UCL: 0.1,
+            LCL: 0.01
+          },
+          samples: [
+            { x: '1', value: 0.05 },
+            { x: '2', value: 0.06 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'np',
+      variables: [
+        {
+          name: 'variable4',
+          stats: {
+            nonconforming: 5,
+            UCL: 10,
+            LCL: 1
+          },
+          samples: [
+            { x: '1', value: 5 },
+            { x: '2', value: 4 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'c',
+      variables: [
+        {
+          name: 'variable5',
+          stats: {
+            count: 20,
+            UCL: 25,
+            LCL: 15
+          },
+          samples: [
+            { x: '1', value: 20 },
+            { x: '2', value: 21 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'u',
+      variables: [
+        {
+          name: 'variable6',
+          stats: {
+            defectsPerUnit: 1.2,
+            UCL: 1.5,
+            LCL: 0.9
+          },
+          samples: [
+            { x: '1', value: 1.2 },
+            { x: '2', value: 1.1 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'I',
+      variables: [
+        {
+          name: 'variable7',
+          stats: {
+            individualValue: 10,
+            UCL: 12,
+            LCL: 8
+          },
+          samples: [
+            { x: '1', value: 10 },
+            { x: '2', value: 11 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'MR',
+      variables: [
+        {
+          name: 'variable8',
+          stats: {
+            movingRange: 2,
+            UCL: 3,
+            LCL: 1
+          },
+          samples: [
+            { x: '1', value: 2 },
+            { x: '2', value: 2.5 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'Histogram',
+      variables: [
+        {
+          name: 'variable9',
+          bins: [
+            { binRange: '0-1', count: 5 },
+            { binRange: '1-2', count: 10 }
+          ]
+        }
+      ]
+    },
+    {
+      chartType: 'Pareto',
+      variables: [
+        {
+          name: 'defectType',
+          categories: [
+            { category: 'Scratch', count: 20 },
+            { category: 'Dent', count: 15 }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/server/controllers/spc-chart/mr.ts

@@ -0,0 +1,30 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateMRChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map((plot, index) => ({
+    ...plot,
+    i: plot.values[0],
+    mr: index == 0 ? 0 : Math.abs(plot.values[0] - plots[index - 1].values[0])
+  }))
+
+  // 변동 범위의 평균을 계산하여 중심선(CL)을 구합니다.
+  const cl = plots.slice(1).reduce((acc, plot) => acc + plot.mr, 0) / (plots.length - 1)
+
+  // 공정 변동을 고려하여 상한 제어선(UCL)을 계산합니다.
+  // MR 차트에서는 3.267 * MR-Bar을 사용합니다 (2개의 측정값을 사용하는 경우).
+  const ucl = 3.267 * cl
+
+  // MR 차트에서 하한 제어선(LCL)은 일반적으로 사용되지 않거나 0으로 설정됩니다.
+  const lcl = 0 // 하한 제어선
+
+  return {
+    chartType: 'MR',
+    controlLimits: {
+      cl,
+      ucl,
+      lcl
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/np.ts

@@ -0,0 +1,30 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateNPChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    defects: plot.values.reduce((sum, v) => sum + v, 0),
+    n: plot.values.length
+  }))
+
+  const totalNonConforming = plots.reduce((acc, plot) => acc + plot.defects, 0)
+  const totalUnits = plots.reduce((acc, plot) => acc + plot.n, 0)
+  const NPBar = totalNonConforming / plots.length // 평균 불량품 수
+
+  // p 차트 공식을 사용하여 UCL과 LCL을 계산합니다.
+  const pBar = totalNonConforming / totalUnits // 전체 불량품 비율
+  const ucl = NPBar + 3 * Math.sqrt(NPBar * (1 - pBar))
+  let lcl = NPBar - 3 * Math.sqrt(NPBar * (1 - pBar))
+  lcl = lcl < 0 ? 0 : lcl // LCL이 음수인 경우 0으로 설정
+
+  return {
+    chartType: 'NP',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: NPBar
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/p.ts

@@ -0,0 +1,29 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculatePChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    defects: plot.values.reduce((sum, v) => sum + v, 0),
+    n: plot.values.length
+  }))
+
+  // 결함 있는 단위의 평균 비율(PBar)을 계산합니다.
+  const totalDefectiveUnits = plots.reduce((acc, plot) => acc + plot.defects, 0)
+  const totalUnits = plots.reduce((acc, plot) => acc + plot.n, 0)
+  const PBar = totalDefectiveUnits / totalUnits
+
+  // 샘플 그룹의 크기(n)에 따라 UCL과 LCL을 계산합니다.
+  const ucl = PBar + 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits)
+  const lcl = PBar - 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits) < 0 ? 0 : PBar - 3 * Math.sqrt((PBar * (1 - PBar)) / totalUnits) // LCL이 음수가 되지 않도록 처리
+
+  return {
+    chartType: 'P',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: PBar
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/pareto.ts

@@ -0,0 +1,32 @@
+interface ParetoCategory {
+  category: string // 카테고리 이름
+  count: number // 해당 카테고리의 데이터 개수 또는 중요도
+}
+
+interface ParetoResult {
+  chartType: 'Pareto'
+  categories: ParetoCategory[] // Pareto 차트에 표시될 카테고리 및 중요도 정보
+}
+
+export function calculatePareto(data: { category: string }[]): ParetoResult {
+  // 각 카테고리별 데이터 개수 계산
+  const categoryCounts: { [category: string]: number } = {}
+  data.forEach(item => {
+    const category = item.category
+    categoryCounts[category] = (categoryCounts[category] || 0) + 1
+  })
+
+  // 카테고리와 데이터 개수를 배열로 변환
+  const categories: ParetoCategory[] = Object.keys(categoryCounts).map(category => ({
+    category,
+    count: categoryCounts[category]
+  }))
+
+  // 데이터 개수에 따라 내림차순으로 정렬
+  categories.sort((a, b) => b.count - a.count)
+
+  return {
+    chartType: 'Pareto',
+    categories
+  }
+}

package/server/controllers/spc-chart/r.ts

@@ -0,0 +1,34 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateRChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플 그룹의 범위를 계산합니다.
+  plots = plots.map(plot => {
+    return {
+      ...plot,
+      r: Math.max(...plot.values) - Math.min(...plot.values)
+    }
+  })
+
+  // 모든 샘플 그룹의 범위의 평균값(R-bar)을 계산합니다.
+  const RBar = plots.reduce((acc, plot) => acc + plot.r, 0) / plots.length
+
+  // 샘플 그룹의 크기(n)에 따라 D3와 D4 값을 설정합니다.
+  // 예시에서는 n=5인 경우의 D3와 D4 값을 사용합니다. 실제 구현에서는 샘플 크기에 맞는 값을 사용해야 합니다.
+  const n = plots[0]?.values.length // 샘플 크기 추정(모든 그룹이 같은 크기를 가정)
+  const D3 = 0 // n=5에 대한 D3 값
+  const D4 = 2.114 // n=5에 대한 D4 값
+
+  // UCL과 LCL을 계산합니다.
+  const ucl = D4 * RBar
+  const lcl = D3 * RBar // D3가 0인 경우, LCL은 0이 됩니다.
+
+  return {
+    chartType: 'R',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: RBar
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/u.ts

@@ -0,0 +1,31 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+export function calculateUChartAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    defects: plot.values.map(Boolean).length,
+    n: plot.values.length
+  }))
+
+  // 단위당 결함 수의 평균(UBar)을 계산합니다.
+  const totalDefects = plots.reduce((acc, plot) => acc + plot.defects, 0)
+  const totalUnits = plots.reduce((acc, plot) => acc + plot.n, 0)
+  const UBar = totalDefects / totalUnits
+
+  // 샘플 그룹의 크기(n)에 따라 상수를 결정합니다. 여기서는 일반적인 상수 값을 사용합니다.
+  const n = plots.length // 샘플 그룹의 수
+  // UCL과 LCL 계산을 위한 상수. 실제 값은 샘플 크기와 분포에 따라 달라질 수 있습니다.
+  const ucl = UBar + 3 * Math.sqrt(UBar / totalUnits)
+  const lcl = UBar - 3 * Math.sqrt(UBar / totalUnits) < 0 ? 0 : UBar - 3 * Math.sqrt(UBar / totalUnits) // LCL이 음수가 되지 않도록 처리
+
+  return {
+    chartType: 'U',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: UBar
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/x-bar-r.ts

@@ -0,0 +1,53 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+function getA2Value(sampleSize: number): number {
+  const a2Values: { [key: number]: number } = {
+    2: 1.88,
+    3: 1.023,
+    4: 0.729,
+    5: 0.577,
+    6: 0.483
+    // 다른 샘플 크기에 대한 A2 값 추가...
+  }
+
+  return a2Values[sampleSize] || 0 // 샘플 크기에 대한 A2 값이 정의되지 않은 경우 0을 반환
+}
+
+export function calculateXBarAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    xbar: plot.values ? plot.values.reduce((sum, val) => sum + val, 0) / plot.values.length : 0,
+    r: Math.max(...plot.values) - Math.min(...plot.values)
+  }))
+
+  const plotSize = plots[0]?.values?.length // 샘플 크기 추정(모든 그룹이 같은 크기를 가정)
+
+  // 각 샘플의 범위(R) 계산
+  const ranges = plots.map(plot => {
+    if (plot.values) {
+      return Math.max(...plot.values) - Math.min(...plot.values)
+    }
+    return 0
+  })
+
+  // 범위(R)의 평균 계산
+  const averageRange = ranges.reduce((sum, r) => sum + r, 0) / ranges.length
+
+  // 전체 평균(중심선, CL) 계산
+  const overallMean = plots.reduce((sum, plot) => sum + plot.xbar, 0) / plots.length
+
+  const A2 = getA2Value(plotSize)
+  const ucl = overallMean + A2 * averageRange
+  const lcl = overallMean - A2 * averageRange
+
+  return {
+    chartType: 'Xbar',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: overallMean
+    },
+    plots
+  }
+}

package/server/controllers/spc-chart/x-bar.ts

@@ -0,0 +1,53 @@
+import { SPCChartPlot, SPCChartAnalysis } from '../../service/spc-chart/spc-chart-type'
+
+function getA2Value(sampleSize: number): number {
+  const a2Values: { [key: number]: number } = {
+    2: 1.88,
+    3: 1.023,
+    4: 0.729,
+    5: 0.577,
+    6: 0.483
+    // 다른 샘플 크기에 대한 A2 값 추가...
+  }
+
+  return a2Values[sampleSize] || 0 // 샘플 크기에 대한 A2 값이 정의되지 않은 경우 0을 반환
+}
+
+export function calculateXBarAnalysisResult(plots: SPCChartPlot[]): SPCChartAnalysis {
+  // 각 샘플의 평균을 계산
+  plots = plots.map(plot => ({
+    ...plot,
+    xbar: plot.values ? plot.values.reduce((sum, val) => sum + val, 0) / plot.values.length : 0,
+    r: Math.max(...plot.values) - Math.min(...plot.values)
+  }))
+
+  const plotSize = plots[0]?.values?.length // 샘플 크기 추정(모든 그룹이 같은 크기를 가정)
+
+  // 각 샘플의 범위(R) 계산
+  const ranges = plots.map(plot => {
+    if (plot.values) {
+      return Math.max(...plot.values) - Math.min(...plot.values)
+    }
+    return 0
+  })
+
+  // 범위(R)의 평균 계산
+  const averageRange = ranges.reduce((sum, r) => sum + r, 0) / ranges.length
+
+  // 전체 평균(중심선, CL) 계산
+  const overallMean = plots.reduce((sum, plot) => sum + plot.xbar, 0) / plots.length
+
+  const A2 = getA2Value(plotSize)
+  const ucl = overallMean + A2 * averageRange
+  const lcl = overallMean - A2 * averageRange
+
+  return {
+    chartType: 'Xbar',
+    controlLimits: {
+      ucl,
+      lcl,
+      cl: overallMean
+    },
+    plots
+  }
+}

package/server/index.ts

@@ -0,0 +1,10 @@
+export * from './service'
+
+import { DataUseCase } from '@things-factory/dataset'
+import { DataUseCaseSPC } from './controllers'
+
+process.on('bootstrap-module-start' as any, async ({ app, config, schema }: any) => {
+  DataUseCase.registerUseCase('SPC', new DataUseCaseSPC())
+
+  console.log('[spc:bootstrap] SPC has just registered as a DataUseCase.')
+})