info

О станции разметки IDP
Общая информация
Разметка документов позволяет обучать и обучать ml-модели, тем самым увеличивая качество распознавания практически до 100%.

Станция разметки IDP - DESIGN-TIME инструмент для выполнения разметки документов, собственная разработка, созданная на основе шаблонов labelstud.io.

Уникальность решения состоит:

Возможность размечать документы категории информации - K2;
Возможность использовать различные шаблоны labelstud.io.

RUN-TIME инструмент для верификации данных, собственная разработка (Vendor free)
В отличии от станции верификации AFC, станция верификации IDP-VS позволяет использовать результаты распознавания различных инструментов извлечения данных:
Результаты распознавания шаблонами AFC
Результаты распознавания шаблонами AFC, вместе с результатами распознавания ML
Результаты распознавания ML
На станции верификации IDP-VS возможна работа с различными типами задач верификации:

Результаты верификации могут быть отгружены со станции верификации в ПКАП для:
Анализа качества распознавания шаблонов AFC
Дообучения ML-моделей
Постановки на автомониторинг ML-моделей
Станция верификации IDP-VS - самостоятельный инструмент распределения и управления задачами
Назначение верификаторов на проект (без оформления заявки в Друге)
Назначение верификатора на задачу (автоматическое и ручное)
Управление контрольным сроком выполнения задач
Ведение отчетности по результатами верификации
Станция верификации IDP-VS имеет возможность встраивания в РМ ОЦ


Для контроля работы верификаторов на станция верификации реализована возможность сбора отчетности по обработке документов

import org.yaml.snakeyaml.Yaml
import org.springframework.boot.gradle.tasks.run.BootRun

buildscript {
    extra.apply {
        set("kotlinVersion", "1.6.0")
        set("springBootVersion", "2.6.1")
    }

    val isSigma = File("$rootDir/sigma.fl").exists()
    repositories {
        val sigmaNexus = "http://sbtatlas.sigma.sbrf.ru"
        val alphaNexus = "http://sbtnexus.delta.sbrf.ru:8081"
        val nexus = if (isSigma) sigmaNexus else alphaNexus
        maven { url = uri("$nexus/nexus/content/repositories/sonatype-public-grid_proxy") }
        maven { url = uri("$nexus/nexus/content/repositories/gradle_plugins_proxy") }
        maven { url = uri("$nexus/nexus/content/repositories/central") }
        maven { url = uri("$nexus/nexus/content/repositories/jcenter") }
        maven { url = uri("$nexus/nexus/content/repositories/jboss") }
        maven { url = uri("$nexus/nexus/content/repositories/springframework") }
        maven { url = uri("$nexus/nexus/content/repositories/thirdparty/") }
    }
    val kotlinVersion = rootProject.extra["kotlinVersion"]
    val springBootVersion = rootProject.extra["springBootVersion"]
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
        classpath("org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion")
        classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlinVersion")
        classpath("gradle.plugin.com.gorylenko.gradle-git-properties:gradle-git-properties:2.2.0")
        classpath("org.yaml:snakeyaml:1.19")
        classpath("gradle.plugin.io.gatling.gradle:gatling-gradle-plugin:3.7.5")
    }
}

val isSigma = File("$rootDir/sigma.fl").exists()

plugins {
    idea
    maven
    jacoco
}

val versionFileName = "version.yml"
val fileInputStream = try {
    java.io.FileInputStream(File("../../$versionFileName"))
} catch (e: Exception) {
    try {
        java.io.FileInputStream(File("../../../$versionFileName"))
    } catch (e: Exception) {
        java.io.FileInputStream(File("../../../../$versionFileName"))
    }
}

val yaml = Yaml()
val versionProps: Map<String, String> = yaml.load(fileInputStream)

val kotlinVersion = rootProject.extra["kotlinVersion"]
val springBootVersion = rootProject.extra["springBootVersion"]

extra.apply {
    set("kotlinStdlibJdk11", "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
    set("kotlinReflect", "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
    set("kotlinxCoroutinesCore", "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0")

    set("springBootTest", "org.springframework.boot:spring-boot-test:$springBootVersion")
    set("springBootStarterTest", "org.springframework.boot:spring-boot-starter-test:$springBootVersion")
    set("springBootStarterWeb", "org.springframework.boot:spring-boot-starter-web:$springBootVersion")
    set("springBootStarterWebServices", "org.springframework.boot:spring-boot-starter-web-services:$springBootVersion")
    set("springBootStarterDataJpa", "org.springframework.boot:spring-boot-starter-data-jpa:$springBootVersion")
    set("springBootStarterActuator", "org.springframework.boot:spring-boot-starter-actuator:$springBootVersion")
    set("springBootStarterRedis", "org.springframework.boot:spring-boot-starter-data-redis:$springBootVersion")
    set("springBootStarterFeign", "org.springframework.cloud:spring-cloud-starter-openfeign:4.0.1")

    set("springDataKeyValue", "org.springframework.data:spring-data-keyvalue:2.6.0")
    set("springKafka", "org.springframework.kafka:spring-kafka:2.8.0")
    set("springRetry", "org.springframework.retry:spring-retry:1.3.1")

    set("logback", "ch.qos.logback:logback-classic:1.2.3")
    set("slf4jApi", "org.slf4j:slf4j-api:1.7.32")
    set("log4jOverSlf4j", "org.slf4j:log4j-over-slf4j:1.7.32")
    set("logstash", "net.logstash.logback:logstash-logback-encoder:7.0.1")

    set("jacksonDatatypeJdk11", "com.fasterxml.jackson.core:jackson-databind:2.13.0")
    set("jacksonDatatypeJdk8", "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.13.0")
    set("jacksonDatatypeJsr310", "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.13.0")
    set("jacksonModuleKotlin", "com.fasterxml.jackson.module:jackson-module-kotlin:2.10.5")

    set("junit", "junit:junit:4.12")

    set("junitJupiterApi", "org.junit.jupiter:junit-jupiter-api:5.8.2")
    set("junitJupiterEngine", "org.junit.jupiter:junit-jupiter-engine:5.8.2")
    set("junitJupiterParams", "org.junit.jupiter:junit-jupiter-params:5.8.2")
    set("junitVintageEngine", "org.junit.vintage:junit-vintage-engine:5.8.2")
    set("junitJupiterLauncher", "org.junit.platform:junit-platform-launcher:1.8.2")

    set("mockitoCore", "org.mockito:mockito-core:4.1.0")
    set("mockitoJupiter", "org.mockito:mockito-junit-jupiter:4.1.0")
    set("mockitoInline", "org.mockito:mockito-inline:4.1.0")
    set("mockitoKotlin", "com.nhaarman.mockitokotlin2:mockito-kotlin:2.2.0")

    set("springDocOpenApiUi", "org.springdoc:springdoc-openapi-ui:1.6.1")

    set("apacheCommonsLang", "org.apache.commons:commons-lang3:3.12.0")
    set("apacheHttpComponents", "org.apache.httpcomponents:httpclient:4.5.13")
    set("micrometer", "io.micrometer:micrometer-registry-prometheus:1.8.1")
    set("postgresql", "org.postgresql:postgresql:42.3.1")
    set("jsonSchemaValidator", "org.everit.json:org.everit.json.schema:1.5.1")
    set("jsonSimple", "com.googlecode.json-simple:json-simple:1.1.1")
    set("kotlinDotEnv", "io.github.cdimascio:dotenv-kotlin:6.2.2")

    set("reflection", "org.reflections:reflections:0.10.2")
    set("imageJ", "net.imagej:ij:1.52h")
    set("awsJavaSdkS3", "com.amazonaws:aws-java-sdk-s3:1.11.490")
    set("hibernateTypes", "com.vladmihalcea:hibernate-types-55:2.14.0")

    set("apacheTikaCore", "org.apache.tika:tika-core:2.3.0")

    set("apachePoi", "org.apache.poi:poi:4.1.0")
    set("apachePoiOoxml", "org.apache.poi:poi-ooxml:4.1.0")

    set("opencv", "org.openpnp:opencv:3.4.2-1")

    set("aop", "org.springframework.boot:spring-boot-starter-aop:$springBootVersion")
}

val servicesModules = subprojects.filter {
    it.depth == 1 && !it.path.contains(":lib") && !it.path.contains(":lt")
}

val ltModule = subprojects.filter {
    it.depth == 1 && it.path.contains(":lt")
}

configure(servicesModules) {
    apply(plugin = "org.springframework.boot")
    apply(plugin = "com.gorylenko.gradle-git-properties")
    apply(plugin = "java")
    configure<org.springframework.boot.gradle.dsl.SpringBootExtension> {
        buildInfo()
    }

    dependencies {
        "implementation"(project(":lib:idp-vs-common"))
    }
}

configure(ltModule) {
    apply(plugin = "io.gatling.gradle")
}

configure(subprojects) {
    repositories {
        val sigmaNexus = "http://sbtatlas.sigma.sbrf.ru"
        val alphaNexus = "http://sbtnexus.delta.sbrf.ru:8081"
        val nexus = if (isSigma) sigmaNexus else alphaNexus
        maven { url = uri("$nexus/nexus/content/repositories/central") }
        maven { url = uri("$nexus/nexus/content/repositories/sonatype-public-grid_proxy") }
        maven { url = uri("$nexus/nexus/content/repositories/jcenter") }
        maven { url = uri("$nexus/nexus/content/repositories/jboss") }
        maven { url = uri("$nexus/nexus/content/repositories/springframework") }
        maven { url = uri("$nexus/nexus/content/repositories/thirdparty/") }
    }

    apply(plugin = "kotlin")
    apply(plugin = "idea")
    apply(plugin = "jacoco")
    apply(plugin = "io.spring.dependency-management")
    apply(plugin = "kotlin-spring")
    apply(plugin = "java-library")

    group = "ru.sbrf.idp"
    version = "${versionProps["version"]}_${versionProps["buildVersion"].toString()}"

    jacoco {
        toolVersion = "0.8.7"
    }

    configure<JavaPluginConvention> {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }

    configurations.all {
        resolutionStrategy.dependencySubstitution {
            substitute(module("org.apache.logging.log4j:log4j-api"))
                .with(module(rootProject.extra["log4jOverSlf4j"] as String))

            substitute(module("org.apache.logging.log4j:log4j-to-slf4j"))
                .with(module(rootProject.extra["log4jOverSlf4j"] as String))
        }
    }

    if (!path.contains("lib") && !path.contains("lt")) {
        tasks.named<BootRun>("bootRun") {
            val activeProfile = System.getProperty("spring.profiles.active")

            systemProperty("spring.profiles.active", activeProfile)
        }
    }

    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
        kotlinOptions {
            freeCompilerArgs = listOf("-Xjsr305=strict")
            jvmTarget = "11"
        }
    }

    tasks.withType<Test> {
        useJUnitPlatform()
        finalizedBy("jacocoTestReport")
        doLast {
            println("View code coverage report at:")
            println("file://$buildDir/reports/jacoco/test/html/index.html")
        }
    }

    tasks.withType<JacocoReport> {
        reports {
            xml.isEnabled = true
        }
    }

    if (path.contains("idp-vs-image-converter")) {
        tasks.register<Copy>("copyFonts") {
            println("Copying font files from font folder to build folder")
            val projectDirectory = layout.projectDirectory
            from(fileTree("$projectDirectory/fonts")) {
                include("**/*.*")
            }
            into("$buildDir/fonts")
        }
    }

    dependencies {
        "api"(rootProject.extra["logback"] as String)
        "api"(rootProject.extra["logstash"] as String)
        "api"(rootProject.extra["reflection"] as String)

        "implementation"(rootProject.extra["kotlinStdlibJdk11"] as String)
        "implementation"(rootProject.extra["kotlinReflect"] as String)
        "implementation"(rootProject.extra["kotlinxCoroutinesCore"] as String)
        "implementation"("javax.xml.bind:jaxb-api:2.3.1")
        "implementation"("com.sun.xml.bind:jaxb-impl:3.0.2")
        "implementation"("com.sun.xml.bind:jaxb-core:3.0.2")
        "implementation"("javax.activation:javax.activation-api:1.2.0")
        "implementation"("commons-io:commons-io:2.6")
        "implementation"("org.apache.logging.log4j:log4j-api:2.15.0")
        "implementation"(rootProject.extra["jacksonDatatypeJdk11"] as String)
        "implementation"(rootProject.extra["jacksonDatatypeJsr310"] as String)
        "implementation"(rootProject.extra["jacksonModuleKotlin"] as String)
        "implementation"(rootProject.extra["kotlinDotEnv"] as String)
        "implementation"(rootProject.extra["apacheCommonsLang"] as String)
        "implementation"(rootProject.extra["micrometer"] as String)

        "implementation"(rootProject.extra["springBootStarterActuator"] as String)
        "implementation"(rootProject.extra["springBootStarterWeb"] as String)
        "testImplementation"(rootProject.extra["springBootTest"] as String)
        "testImplementation"(rootProject.extra["springBootStarterTest"] as String)

        "testImplementation"(rootProject.extra["junitJupiterApi"] as String)
        "testImplementation"(rootProject.extra["junitJupiterEngine"] as String)
        "testImplementation"(rootProject.extra["junitJupiterParams"] as String)
        "testImplementation"(rootProject.extra["junitJupiterParams"] as String)
        "testImplementation"(rootProject.extra["junitJupiterLauncher"] as String)
        "testImplementation"(rootProject.extra["mockitoCore"] as String)
        "testImplementation"(rootProject.extra["mockitoJupiter"] as String)
        "testImplementation"(rootProject.extra["mockitoKotlin"] as String)
        "testImplementation"(rootProject.extra["mockitoInline"] as String)
    }
}