feat: Add support for VIAME model inference settings view and backend…

app.js

@@ -44,6 +44,7 @@ const {
     getYoloXInferenceSettingsPage,
     getYoloXTrainingSettingsPage,
     getInceptionSettingsPage,
+    getViameSettingsPage,
 } = require("./routes/pages");
 
 // middleware
@@ -84,6 +85,7 @@ app.get("/yolo/yolovXSettings", getYoloXSettingsPage);
 app.get("/yolo/yolovXInferenceSettings", getYoloXInferenceSettingsPage);
 app.get("/yolo/yolovXTrainingSettings", getYoloXTrainingSettingsPage);
 app.get("/inference/inceptionSettings", getInceptionSettingsPage);
+app.get("/inference/viameSettings", getViameSettingsPage);
 app.get("/user", getUserPage);
 app.get("/servstats", getServerStatsPage);
 app.get("/homeV", getValidationHomePage);

routes/api.js

@@ -88,11 +88,13 @@ const yoloInference = require("./inference/yoloInference");
 const getRunImages = require("./inference/getRunImages");
 const uploadInferenceFile = require("./inference/uploadInferenceFile");
 const inceptionInference = require("./inference/inceptionInference");
+const viameInference = require("./inference/viameInference");
 const addYoloInferenceToDataset = require("./inference/addYoloInferenceToDataset");
 
 // INFERENCE ROUTES
 api.post("/yolo-inf", yoloInference);
 api.post("/inception-inf", inceptionInference);
+api.post("/viame-inf", viameInference);
 api.post("/upload_inference_file", uploadInferenceFile);
 api.get("/runs/:runId/images", getRunImages);
 api.post("/inference/add-inference-run-to-dataset", addYoloInferenceToDataset);

routes/inference/viameInference.js

@@ -0,0 +1,105 @@
+const fs = require("fs");
+const queries = require("../../queries/queries");
+const { exec } = require("child_process");
+const path = require("path");
+
+async function viameInference(req, res) {
+    try {
+        let date = Date.now();
+
+        let PName = req.body.PName,
+            Admin = req.body.Admin,
+            log = `${date}.log`,
+            inferenceFile = req.body.inference_file,
+            device = req.body.device || "cpu",
+            weightName = req.body.weights;
+
+        var errFile = `${date}-error.log`;
+
+        var publicPath = currentPath,
+            mainPath = publicPath + "public/projects/",
+            projectPath = mainPath + Admin + "-" + PName,
+            trainingPath = projectPath + "/training",
+            inferencePath = projectPath + "/inference",
+            inferenceUploadPath = projectPath + "/inference/uploads/",
+            logsPath = inferencePath + "/logs",
+            runPath = `${logsPath}/${date}`,
+            weightPath = trainingPath + "/weights/" + weightName,
+            viameScript = publicPath + "controllers/inference/viame.py";
+
+        let inferenceFilePath = inferenceFile;
+        if (!fs.existsSync(inferenceFilePath)) {
+            const fallbackInferenceFilePath = path.join(inferenceUploadPath, inferenceFilePath);
+            if (fs.existsSync(fallbackInferenceFilePath)) {
+                inferenceFilePath = fallbackInferenceFilePath;
+            }
+        }
+
+        if (!fs.existsSync(logsPath)) {
+            fs.mkdirSync(logsPath);
+        }
+
+        if (!fs.existsSync(runPath)) {
+            fs.mkdirSync(runPath);
+        }
+
+        fs.writeFileSync(`${runPath}/${log}`, "");
+        fs.writeFileSync(`${runPath}/type.txt`, "viame");
+
+        let viameScriptCopyPath = runPath + "/viame.py";
+        if (!fs.existsSync(viameScriptCopyPath)) {
+            fs.copyFileSync(viameScript, viameScriptCopyPath);
+        }
+
+        let existingClasses;
+        try {
+            existingClasses = await queries.project.getAllClasses(projectPath);
+        } catch (err) {
+            global.logger.error(err);
+            return res.status(500).send("Error fetching classes");
+        }
+
+        for (let i = 0; i < existingClasses.rows.length; i++) {
+            fs.appendFileSync(`${runPath}/classes.txt`, `${existingClasses.rows[i].CName}\n`);
+        }
+
+        let cmd = `python3 ${viameScript} -i "${inferenceFilePath}" -n "${runPath}/classes.txt" -w "${weightPath}" -o "${runPath}/output" -d "${device}"`;
+
+        let success = "";
+        fs.writeFileSync(`${runPath}/${log}`, `${cmd}\n\n`);
+
+        exec(cmd, (err, stdout, stderr) => {
+            if (err) {
+                global.logger.error(err);
+                global.logger.debug(`Error: ${err.message}`);
+
+                if (err.message != "stdout maxBuffer length exceeded") {
+                    success = err.message;
+                    fs.writeFileSync(`${runPath}/${errFile}`, success);
+                }
+            } else if (stderr) {
+                global.logger.debug(`stderr: ${stderr}`);
+
+                if (stderr != "stdout maxBuffer length exceeded") {
+                    fs.writeFileSync(`${runPath}/${errFile}`, stderr);
+                }
+            }
+
+            const completionData = {
+                status: err ? 'error' : 'success',
+                timestamp: date,
+                zipAvailable: fs.existsSync(`${runPath}/inference_results.zip`),
+                csvAvailable: fs.existsSync(`${runPath}/inference_stats.csv`)
+            };
+
+            fs.writeFileSync(`${runPath}/done.log`, JSON.stringify(completionData, null, 2));
+        });
+
+        res.send({ Success: `VIAME Inference Started` });
+    } catch (err) {
+        global.logger.error(err);
+        return res.status(500).send("Error running inference");
+    }
+}
+
+module.exports = viameInference;

routes/pages.js

@@ -34,6 +34,7 @@ const getYolo3SettingsPage = require("./pages/getYolo3SettingsPage");
 const getUserPage = require("./pages/getUserPage");
 const get404Page = require("./pages/get404Page");
 const getInceptionSettingsPage = require("./pages/getInceptionSettingsPage");
+const getViameSettingsPage = require("./pages/getViameSettingsPage");
 
 module.exports = {
     getLoginPage: getLoginPage,
@@ -72,4 +73,5 @@ module.exports = {
     getInferencePage: getInferencePage,
     getTrainingPage: getTrainingPage,
     getInceptionSettingsPage: getInceptionSettingsPage,
+    getViameSettingsPage: getViameSettingsPage,
 };

routes/pages/getInferencePage.js

@@ -361,17 +361,22 @@ async function getProcessingPage(req, res) {
                 run_types.push("Inception");
             } else if (type.trim() === "yolo") {
                 run_types.push("YOLO");
+            } else if (type.trim() === "viame") {
+                run_types.push("VIAME");
             } else {
                 run_types.push("Unknown");
             }
         } else {
             const inceptionExists = fileExistsRecursive(run_path_inf, "inception.py");
             const yoloExists = fileExistsRecursive(run_path_inf, "datatovalues.py");
+            const viameExists = fileExistsRecursive(run_path_inf, "viame.py");
 
             if (inceptionExists) {
                 run_types.push("Inception");
             } else if (yoloExists) {
                 run_types.push("YOLO");
+            } else if (viameExists) {
+                run_types.push("VIAME");
             } else {
                 run_types.push("Unknown");
             }

routes/pages/getViameSettingsPage.js

@@ -0,0 +1,156 @@
+const fs = require("fs");
+const sqlite3 = require("sqlite3").verbose();
+
+async function getViameSettingsPage(req, res) {
+    // get URL variables
+    var IDX = parseInt(req.query.IDX),
+        user = req.cookies.Username;
+
+    if (isNaN(IDX)) {
+        IDX = 0;
+        return res.redirect("/home");
+    }
+    if (user == undefined) {
+        return res.redirect("/");
+    }
+
+    var projects = await db.allAsync(
+        "SELECT * FROM Access WHERE Username = '" + user + "'",
+    );
+    var num = IDX;
+
+    if (num >= projects.length) {
+        return res.redirect("/home");
+    }
+    var PName = projects[num].PName;
+    var admin = projects[num].Admin;
+
+    // set paths
+    var public_path = currentPath,
+        main_path = public_path + "public/projects/",
+        project_path = main_path + admin + "-" + PName,
+        path = project_path + "/" + PName + ".db",
+        training_path = project_path + "/training",
+        weights_path = training_path + "/weights",
+        inference_path = project_path + "/inference",
+        inference_upload_path = project_path + "/inference/uploads",
+        log_path = training_path + "/logs/";
+
+    if (!fs.existsSync(training_path)) {
+        fs.mkdirSync(training_path);
+    }
+    if (!fs.existsSync(weights_path)) {
+        fs.mkdirSync(weights_path);
+    }
+    if (!fs.existsSync(inference_path)) {
+        fs.mkdirSync(inference_path);
+    }
+    if (!fs.existsSync(inference_upload_path)) {
+        fs.mkdirSync(inference_upload_path, { recursive: true });
+    }
+
+    // connect to project database
+    var tdb = new sqlite3.Database(path, (err) => {
+        if (err) {
+            return global.logger.error(err.message);
+        }
+    });
+
+    // create async database object functions
+    tdb.getAsync = function(sql) {
+        var that = this;
+        return new Promise(function(resolve, reject) {
+            that.get(sql, function(err, row) {
+                if (err) {
+                    global.logger.error("runAsync ERROR!", err)
+                    reject(err);
+                } else resolve(row);
+            });
+        }).catch((err) => {
+            global.logger.error(err);
+        });
+    };
+    tdb.allAsync = function(sql) {
+        var that = this;
+        return new Promise(function(resolve, reject) {
+            that.all(sql, function(err, row) {
+                if (err) {
+                    global.logger.error("runAsync ERROR!", err)
+                    reject(err);
+                } else resolve(row);
+            });
+        }).catch((err) => {
+            global.logger.error(err);
+        });
+    };
+
+    var results1 = await db.getAsync(
+        "SELECT * FROM `Projects` WHERE PName = '" +
+        PName +
+        "' AND Admin = '" +
+        admin +
+        "'",
+    );
+    var results2 = await tdb.allAsync("SELECT * FROM `Classes`");
+
+    var acc = await db.allAsync(
+        "SELECT * FROM `Access` WHERE PName = '" +
+        PName +
+        "' AND Admin = '" +
+        admin +
+        "'",
+    );
+    var access = [];
+    for (var i = 0; i < acc.length; i++) {
+        access.push(acc[i].Username);
+    }
+
+    // Get files
+    var global_weights = [];
+    try {
+        global_weights = await readdirAsync(weights_path);
+    } catch (e) {
+        global.logger.error(e);
+    }
+
+    var global_inference = [];
+    try {
+        global_inference = await readdirAsync(inference_path);
+    } catch (e) {
+        global.logger.error(e);
+    }
+
+    var global_inference_upload = [];
+    try {
+        global_inference_upload = await readdirAsync(inference_upload_path);
+    } catch (e) {
+        global.logger.error(e);
+    }
+    global_inference_upload.push(project_path + "/images");
+
+    // close the database
+    tdb.close(function(err) {
+        if (err) {
+            global.logger.error(err);
+        }
+    });
+
+    res.render("training/viameSettings", {
+        title: "viameSettings",
+        user: req.cookies.Username,
+        access: access,
+        PName: PName,
+        Admin: admin,
+        IDX: IDX,
+        PDescription: results1.PDescription,
+        AutoSave: results1.AutoSave,
+        classes: results2,
+        global_weights: global_weights,
+        global_inference: global_inference,
+        global_inference_upload: global_inference_upload,
+        logged: req.query.logged,
+        activePage: "viameSettings",
+    });
+}
+
+module.exports = getViameSettingsPage;