Qc script

.vscode/settings.json

@@ -1,5 +1,9 @@
 {
     "githubPullRequests.ignoredPullRequestBranches": [
         "main"
-    ]
+    ],
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    },
+    "python.formatting.provider": "none"
 }

audiodata.csv

@@ -0,0 +1 @@
+""

nulrdcscripts/staging/vqc/QCScript.py

@@ -0,0 +1,8 @@
+import videoanalyses.fbyfYUV as fbyfYUV
+from setupsteps import setup
+
+videoBitDepth = setup.setVideoBitDepth("--10bit")
+videoBitDepth = setup.setvideobitdepthstandard(videoBitDepth)
+videodata = "data\data.txt"
+
+errors = fbyfYUV.checkerrors(videodata, videoBitDepth)

nulrdcscripts/staging/vqc/data/ReferenceData10Bit.txt

@@ -0,0 +1,36 @@
+10 Bit Data Ranges for Average Videos
+
+Digital Luma Range: 64-940
+Digital Chroma Range: 64 - 960
+Ideal U & V Range: 340 - 680
+Yav: ~512
+Yrang: ~516 - 876
+Uav: ~512
+Vav: ~512
+TOUT: 0 - 0.009
+TOUTc: <10
+SAT Ideal Range: 0 - 88.7
+SATb: <1000 frames
+SATi: <1000 frames
+Hue Ideal Range: 480 - 588 (for skin tones)
+BRNGav: <0.02
+BRNGc: <1000
+MSEf: ~0
+MSEfY: <10
+VREP Ideal: 0
+
+Y Channel Range: 0-1020 IRE
+Y Channel Ideal Range: 64 - 940 IRE
+    Y LOW : 64 IRE
+    Y AVG : 512 IRE
+    Y HIGH : 940 IRE
+
+U Channel Ideal Range: 340 - 680 IRE
+V Channel Ideal Range: 340 - 680 IRE
+
+
+YUV Diff : Closer to 0 the better
+
+SAT Ideal RAnge: 0 - 354.8
+
+

nulrdcscripts/staging/vqc/data/dataframe.py

@@ -0,0 +1,10 @@
+import pandas as pd
+
+csv = "Video8BitValues.csv"
+
+df = pd.read_csv(csv, index_col="criteria")
+criteriaToCheck = "brngout"
+criteria = "uhigh"
+extraction = df.at[criteria, criteriaToCheck]
+
+print(extraction)

nulrdcscripts/staging/vqc/data/severityLevels.py

@@ -0,0 +1,4 @@
+vrep = "CRITICAL"
+tout = "CRITICAL"
+brngout = "MODERATE"
+clipping = "CRITICAL"

nulrdcscripts/staging/vqc/data/test.py

@@ -0,0 +1,90 @@
+import videovalues10Bit
+
+videodata = "baddata.csv"
+
+
+def runLOW(criteria):
+    criteria = criteria + "low"
+    return criteria
+
+
+def runHIGH(criteria):
+    criteria = criteria + "high"
+    return criteria
+
+
+def checkLOWHIGH(videodata, videoBitDepth, fullCriteria):
+    criteriaBRNG = videoBitDepth.get(fullCriteria["BRNG"])
+    criteriaClipping = videoBitDepth.get(fullCriteria["clipping"])
+    selectColumns = "" + fullCriteria + "," + "Frame Time" + ""
+    BRNGErrors = setAndRunBRNG(criteriaBRNG, fullCriteria, selectColumns, videodata)
+    clippingErrors = setAndRunClipping(
+        criteriaClipping, fullCriteria, selectColumns, videodata
+    )
+
+    if BRNGErrors.isEmpty and clippingErrors.isEmpty:
+        pass
+    elif BRNGErrors.isEmpty or clippingErrors.isEmpty:
+        if BRNGErrors.isEmpty:
+            videoYUVErrors = clippingErrors
+        else:
+            videoYUVErrors = BRNGErrors
+    else:
+        videoYUVErrors = [clippingErrors, BRNGErrors]
+    return videoYUVErrors
+
+
+def setAndRunClipping(criteria, criteriaClipping, selectColumns, videodata):
+    criteriaEquation = "" + criteria + "==" + criteriaClipping + ""
+    clippingErrors = {}
+    subDF = videodata[[selectColumns]]
+
+    clippingErrors = subDF.query(criteriaEquation)
+    if subDF.empty:
+        pass
+    else:
+        if criteria.contains("low"):
+            errortype = "Low Clipping"
+        elif criteria.contains("high"):
+            errortype = "High Clipping"
+        clippingErrors.assign(errortype)
+
+    return clippingErrors
+
+
+def setAndRunBRNG(criteria, criteriaBRNG, selectColumns, videodata):
+    if criteria.contains("low"):
+        firstOp = "=<"
+        clipVal = 0
+    elif criteria.contains("high"):
+        firstOp = ">="
+        clipVal = 1023
+    criteriaEquation = (
+        "" + criteria + firstOp + criteriaBRNG + "&" + criteria + "!=" + clipVal + ""
+    )
+    BRNGErrors = {}
+    subDF = videodata[[selectColumns]]
+
+    BRNGErrors = subDF.query(criteriaEquation)
+    if BRNGErrors.isEmpty:
+        pass
+    else:
+        if criteria.contains("low"):
+            errortype = "Low BRNG"
+        elif criteria.contains("high"):
+            errortype = "High BRNG"
+        BRNGErrors.assign(errortype)
+    return BRNGErrors
+
+
+def check():
+    videodata = "baddata.csv"
+    criteria = "Y"
+    videoBitDepth = videovalues10Bit
+    fullCriteria = runLOW(criteria)
+    checkLOWHIGH(videodata, videoBitDepth, fullCriteria)
+    fullCriteria = runHIGH(criteria)
+    checkLOWHIGH(videodata, videoBitDepth, fullCriteria)
+
+
+check()

nulrdcscripts/staging/vqc/docs/continue.py

@@ -0,0 +1,59 @@
+import pandas as pd
+import xml.etree.ElementTree as etree
+import cleaners
+
+audiodata = {}
+videodata = {}
+framenumberA = 0
+framenumberV = 0
+
+
+file = input("file")
+data = "data.json"
+tree = etree.parse(file)
+root = tree.getroot()
+
+
+for event, elem in etree.iterparse(file, events=["start", "end"]):
+    if event == "start":
+        if elem.tag == "frame":
+            if elem.get("media_type") == "audio":
+                framenumberA = framenumberA + 1
+                frametime = elem.get("pkt_pts_time")
+                audiodata[framenumberA] = {}
+                for tag in elem.iter("tag"):
+                    criteria = tag.attrib["key"]
+                    criteria = cleaners.criteriacleaner(criteria)
+                    value = tag.attrib["value"]
+                    audiodata[framenumberA]["Frame Time"] = float(frametime)
+                    audiodata[framenumberA][criteria] = value
+            else:
+                pass
+        else:
+            pass
+    elif event == "end":
+        elem.clear()
+
+
+for event, elem in etree.iterparse(file, events=["end"]):
+    if event == "end":
+        if elem.tag == "frame":
+            if elem.get("media_type") == "video":
+                framenumberV = framenumberV + 1
+                frametime = elem.get("pkt_pts_time")
+                videodata[framenumberV] = {}
+                for tag in elem.iter("tag"):
+                    criteria = tag.attrib["key"]
+                    criteria = cleaners.criteriacleaner(criteria)
+                    value = tag.attrib["value"]
+                    videodata[framenumberV]["Frame Time"] = float(frametime)
+                    videodata[framenumberV][criteria] = float(value)
+            elem.clear()
+
+dfAudio = pd.DataFrame.from_dict(audiodata)
+dfAudio = dfAudio.transpose()
+dfAudio.to_csv("audiodata.csv", sep=",")
+
+dfVideo = pd.DataFrame.from_dict(videodata)
+dfVideo = dfVideo.transpose()
+dfVideo.to_csv("videodatashort.csv", sep=",")

nulrdcscripts/staging/vqc/docs/summarizationStats.md

@@ -0,0 +1,36 @@
+## Standards from QC Tools that have been altered for this script
+
+|Criteria|Original Value|
+|:---:|:---:|
+|TOUTc|<10 frames|
+|SATb|<1000 frames|
+|SATi|<1000 frames|
+|BRNGc|<1000 frames|
+|MSEfY|<10 frames|
+
+
+## Knowns (rounded frames per second)
+
+30 frames/sec <br>
+3,600 sec/hr <br>
+108,000 frames/hr
+
+### Calculations for TOUTc and MSEfY
+Equation: 10/((3600*timeHRs) \* 30) (This makes no sense as the values are E<sup>-5</sup>)
+
+### Calculations for SATb, SATi, BRNGc
+Equation:  1000/((3600*timeHRs) \* 30)
+
+#### If we can assume that the 1000 benchmark value came from a video in the range of 1-2 hrs
+
+|Time|Percent Error Allowed Exact| Percent Error Allowed Rounded|
+|:---:|:---:|:---:|
+1 hr|0.92592593%|0.93%
+1.25 hr|0.74074074%|0.74%
+1.5 hr|0.61728395%|0.62%
+1.75 hr| 0.52910053%|0.53%
+2 hr|0.4629629%|0.46%
+||
+AVG| 0.65520282%|0.66%
+
+Theoretically 0.66% of the videos frames are allowed to be greater