Page Comparison

let finalValues =[]
let i=0
while(i < 100 ) {
  i = i + 1
  finalValues.push( {
    "id": i,
    "curTime": 0,
    "endTime": i + 1,
    "startTime": i ,
    "UIstartTime": i + 1,
    "UIendTime": i,
    "split": 0,
    "audiourl": "",
    "pos": 0,
    "transliterationData": "abc def ghi jxy lzg".split(" ").map(w => ({
            "nameword": "Price"w,
            "fieldTypetags": "Text"[],

           "mandatoryFieldlanguageTag": false"",
 
          "possible_value": [
               editedText": ""
      }))
  })
}
 ],

let x =         "default_value": ""
        }
    ]
  }),
  CarJSON.stringify(finalValues)
this.updateAnnotations(x)

let newClass = {
  Books: JSON.stringify({
    "color": "#FF000#FFEBE8",
    "hotkey": "c",
    "attributes": [
        {
            "name": "attr1Price",
            "fieldType": "DropDownText",
            "mandatoryField": false,
            "possible_value": [
                "attr1_v1",
            ],
   "attr1_v2"         "default_value": ""
  ],      }
    ]
  }),
  Car: JSON.stringify({
"default_value    "color": "attr1_v1"#FF000",
    "hotkey": "c",
     },"attributes": [
        {
            "name": "attr2attr1",
            "fieldType": "DropDown",
            "mandatoryField": false,
            "possible_value": [
                "attr2attr1_v1",
                "attr2attr1_v2"
            ],
            "default_value": "attr2attr1_v1"
        },
    ]   }), {
 Quills: JSON.stringify({     "color": "#C23456",     "hotkeyname": "qattr2",
    "attributes": [         {
            "name": "Colour",
            ""fieldType": "TextDropDown",
            "mandatoryField": false,
            "possible_value": [
                "Blueattr2_v1",
                "Greenattr2_v2",
                "Yellow"],
               "default_value": "Redattr2_v1",
        }
    ]
  "White"}),
  Quills: JSON.stringify({
      "color": "#C23456",
    "hotkey": "Orangeq",
    "attributes": [
      ],  {
            "default_valuename": "blueColour",
        }    "fieldType": "Text",
]   }),   Tree: JSON.stringify({     "colormandatoryField": "#CCC"false,
     "hotkey": "t",       "attributespossible_value": [
        {        "Blue",
    "name": "attr1",             "fieldType": "MultiDropDown",Green",
                "mandatoryField": false,Yellow",
                "possible_value": [Red",
                "attr1_v1White",
                "attr1_v2Orange"
            ],
            "default_value": "blue"
        },
    ]
  }),
{  Tree: JSON.stringify({
    "color": "#CCC",
    "namehotkey": "attr2t",
    "attributes": [
       "fieldType": "Text", {
            "mandatoryFieldname": false"attr1",
            "possible_valuefieldType": ["MultiDropDown",
            "mandatoryField": false,
    ""        "possible_value": [
   ],             "defaultattr1_valuev1":,
  ""         }     ]"attr1_v2"
  }),   Van: JSON.stringify({     "color": "#F24110", ],
            "hotkeydefault_value": "v",
       "attributes": [ },
        {
            "name": "Vansattr2",
            "fieldType": "DropDownText",
            "mandatoryField": false,
            "possible_value": [
                "Ferrari",
            ],
   "Kia",         "default_value": ""
      "MG"  }
    ]
  }),
  ],
Van: JSON.stringify({
    "color": "#F24110",
     "default_valuehotkey": "v",
    "attributes": [
  }     ] {
 }) };  this.changeAnnotationClasses(newClass);

let groupList = ["a", "b", "c", "d"]
localStorage.setItem("groups", JSON.stringify(groupList))

let yoloData = inputValues["yolo-data"]

// split yolo annotation data to array of individual anno data
let re = /\b[\w.]+(?:[^\w\n]+[\w.]+){0,4}\b/g
let arrYoloAnno = yoloData.match(re);

/* Start: configure unique classes from custom code*/
// let yoloClasses = []
// arrYoloAnno.forEach(y => {
//   let currentClass = y.substr(0, y.indexOf(" "))
//   if(!yoloClasses.includes(currentClass)){
//     yoloClasses.push(currentClass)
//   }
// })
// make class data
// let newClass = {}
// yoloClasses.forEach(c => {
//   let classValue = {
//     "color": '#'+(0x1000000+Math.random()*0xffffff).toString(16).substr(1,6), // random color
//     "hotkey": "",
//     "attributes": []
//   }
//   newClass[c] = JSON.stringify(classValue)
// })

// this.changeAnnotationClasses(newClass);
/* End */

/* Class data*/
let newClass = {
    "0": "Person",
    "1": "Class1",
    "2": "Class2",
    "3": "Class3",
    "4": "Class4",
    "5": "Class5",
    "6": "Class6",
    "7": "Class7",
    "8": "Class8",
    "9": "Class9",
    "99": "Face"
  }
/**/


/* Start: convert yolo data to TM anno format and setting it as pre anno */
/* 
The format of the YOLO label file is
Label_ID_1 X_CENTER_NORM Y_CENTER_NORM WIDTH_NORM HEIGHT_NORM
*/
let preAnno = arrYoloAnno.map((singleYoloAnno, ind) => {
  let singleAnnoSplitData = singleYoloAnno.split(" ")
  let X_CENTER = parseFloat(singleAnnoSplitData[1])
  let Y_CENTER = parseFloat(singleAnnoSplitData[2])
  let WIDTH_NORM = parseFloat(singleAnnoSplitData[3])/2
  let HEIGHT_NORM = parseFloat(singleAnnoSplitData[4])/2

  let firstPoint = [X_CENTER - WIDTH_NORM, Y_CENTER - HEIGHT_NORM]
  let secondPoint = [X_CENTER + WIDTH_NORM, Y_CENTER - HEIGHT_NORM]
  let thirdPoint = [X_CENTER + WIDTH_NORM, Y_CENTER + HEIGHT_NORM]
  let fourthPoint = [X_CENTER - WIDTH_NORM, Y_CENTER + HEIGHT_NORM]

  return ({
    "id":ind,
    "label":[newClass[singleAnnoSplitData[0]]],
    "shape":"rectangle",
    "points":[firstPoint,secondPoint,thirdPoint,fourthPoint],
    "notes":"",
    "annotationGroups":"",
    "attributes":{},
    "imageWidth":undefined,
    "imageHeight":undefined
  })
})
/* End */


let x =  JSON.stringify(preAnno)
this.updateAnnotations(x)

let preAnno = inputValues["Preannotations"]

if(!isNaN(currentUserLevel) && currentUserLevel == 1 && Array.isArray(annotations) && annotations.length > 0){
  let annoData = []
  let preAnnoArr = _.get(preAnno, "document.page[0].block", [])
  let tmAnnoFormat = preAnnoArr.map((val, i) => {
    return ({
      "id":i,
      "label":["car"],
      "shape":"rectangle",
      "points":[firstPoint,secondPoint,thirdPoint,fourthPoint],
      "notes":"",
      "annotationGroups":"",
      "attributes":{},
      "imageWidth":undefined,
      "imageHeight":undefined
    })
  })
  let x =  JSON.stringify(tmAnnoFormat)
  this.updateAnnotations(x)
}

/* START */
let alertMessage = []
annotations.forEach(anno => {
  if(!_.get(anno, "annotationGroups") && !_.get(anno, "label", []).includes("other_value_text")) {
this.allowSubmit = false
    alertMessage.push(`One of the objects of class ${_.get(anno, "label", [])[0]} of shape ${_.get(anno, "shape", "")} has not been added to a group.`)
  }
})

if(alertMessage.length){
  this.displayErrors(alertMessage)
} else {
  this.allowSubmit = true
}
/* END */

let x = {"text":"Ceci","start":1,"end":5,"id":0,"ws":true}
var anns = {}
anns["version"] = 2
anns["annotations"] = {}
anns["annotations"]["entities"] = []
anns["annotations"]["entities"].push({
  "uuid": "1",
  "start_offset": x["start"],
  "end": x["end"],
  "entity_pos":"",
  "text": x["text"],
  "attributes":{},
  "taskId":"3517133",
  "entity_type":"ORG"
})
let updateAnnoData = [{
  "key": "3517133",
  "value": anns
}]
console.log('preanns', updateAnnoData)
this.updateAnnotations(updateAnnoData)

let currentUserId = localStorage.getItem("userId")
if(currentUserLevel === 1){
  this.changeFormValue("annotator_id", `${currentUserId}`)
}
if(currentUserLevel === 2){
  this.changeFormValue("QA_id", `${currentUserId}`)
  if(rejectTaskDetails.commentHistory.length > 0){
    console.log("QA_Flag set to true on load")
    this.changeFormValue("QA_Flag", true)
  }
}

/* O/P format: "gemini(brand),100 grams(quantity) */
let entities = _.get(annotations, "[0].value.annotations.entities", _.get(annotations, "annotations.entities", []))
if (entities.length > 0) {
  entities.sort((a,b) => a.start_offset - b.start_offset)
  var requiredOp = entities.reduce((accumulator, currentValue) => accumulator + `${currentValue.text}(${currentValue.entity_type}),`, "")
  if(requiredOp[requiredOp.length - 1] == ","){
    requiredOp = requiredOp.slice(0, requiredOp.length-1)
  }
  this.changeFormValue("tagged_output", requiredOp)

function time2sec(dateTime) {
    let ms = dateTime.split(',')[1]
    let hh = dateTime.split(':')[0]
    let mm = dateTime.split(':')[1]
    let ss = dateTime.split(':')[2].split(',')[0]

    let ts = (parseInt(hh) * 3600) + (parseInt(mm) * 60) + parseInt(ss) + (parseInt(ms) / 1000)
    return ts
}

let finalValues = []
let inputArray = inputValues["TEXT"].split(/\n\s*\n/)


let i=0
while(i < inputArray.length) {
  i = i + 1
  if(inputArray[i]) {
  let startTime = time2sec(inputArray[i].split('\n')[1].split('-->')[0])
  let endTime = time2sec(inputArray[i].split('\n')[1].split('-->')[1])
  finalValues.push( {
    "id": i,
    "curTime": 0,
    "endTime": endTime,
    "startTime": startTime ,
    "UIstartTime": startTime,
    "UIendTime": endTime,
    "split": 0,
    "audiourl": "",
    "pos": 0,
    "transliterationData": inputArray[i].split('\n')[2].split(" ").map(w => ({
          "word": w,
          "tags": [],
          "languageTag": "",
          "editedText": ""
      }))
  })
  
  }
}
 
 
let x =  JSON.stringify(finalValues)
this.updateAnnotations(x)