372 lines
11 KiB
JavaScript
372 lines
11 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// src/hooks/useIntelligentTracking/index.tsx
|
|
var useIntelligentTracking_exports = {};
|
|
__export(useIntelligentTracking_exports, {
|
|
ModifyTrackCameras: () => ModifyTrackCameras,
|
|
createIntelligentTrack: () => createIntelligentTrack,
|
|
deleteTrackById: () => deleteTrackById,
|
|
emitHeartbeat: () => emitHeartbeat,
|
|
getCameraInfoByCircle: () => getCameraInfoByCircle,
|
|
getDefaultRadius: () => getDefaultRadius,
|
|
getSearchIntervalDuration: () => getSearchIntervalDuration,
|
|
getTackCameraInfo: () => getTackCameraInfo,
|
|
getTackDetailInfo: () => getTackDetailInfo,
|
|
getTaskCameraByCenterAndPower: () => getTaskCameraByCenterAndPower,
|
|
getTrackTaskById: () => getTrackTaskById,
|
|
modifyTrackConf: () => modifyTrackConf,
|
|
modifyTrackImgs: () => modifyTrackImgs,
|
|
operateTrackById: () => operateTrackById,
|
|
setDefaultRadius: () => setDefaultRadius,
|
|
setIntelligentTrackCircleInfo: () => setIntelligentTrackCircleInfo,
|
|
setSearchIntervalDuration: () => setSearchIntervalDuration,
|
|
taskInfoToSearchItem: () => taskInfoToSearchItem
|
|
});
|
|
module.exports = __toCommonJS(useIntelligentTracking_exports);
|
|
var turf = __toESM(require("@turf/turf"));
|
|
var import_useTaskState = require("../useTaskState");
|
|
var import_Tree = __toESM(require("@common/components/CameraTree/Tree"));
|
|
var import_request = __toESM(require("../../utils/request"));
|
|
var import_meta = require("@zhst/meta");
|
|
var import_utils = require("@common/components/CameraTree/utils");
|
|
var import_func = require("@zhst/func");
|
|
var defaultFaceThreshold = 0.68;
|
|
var defaultBodyThreshold = 0.7;
|
|
var defaultFaceResultNum = 5;
|
|
var defaultRadius = 0.15;
|
|
var defaultQueryCycle = 10;
|
|
var getDefaultRadius = () => {
|
|
return defaultRadius;
|
|
};
|
|
var setDefaultRadius = (radius) => {
|
|
defaultRadius = radius;
|
|
};
|
|
var searchIntervalDuration = 10;
|
|
var setSearchIntervalDuration = (duration) => {
|
|
searchIntervalDuration = duration;
|
|
};
|
|
var getSearchIntervalDuration = (time) => {
|
|
return time;
|
|
};
|
|
var operateTrackById = async (smartTrackId, operationType) => {
|
|
try {
|
|
const data = {
|
|
operationType,
|
|
smartTrackId
|
|
};
|
|
await (0, import_request.default)({
|
|
method: "PUT",
|
|
url: "/singer.SmartTrackService/OperationSmartTrack",
|
|
data
|
|
});
|
|
import_meta.message.success("操作成功");
|
|
} catch (err) {
|
|
console.error(err);
|
|
import_meta.message.success("操作失败");
|
|
}
|
|
};
|
|
var deleteTrackById = async (smartTrackId) => {
|
|
try {
|
|
await (0, import_request.default)({
|
|
method: "DELETE",
|
|
url: "/singer.SmartTrackService/DeleteSmartTrack",
|
|
data: {
|
|
smartTrackId
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
};
|
|
var modifyTrackImgs = async (smartTrackId, images) => {
|
|
try {
|
|
await (0, import_request.default)({
|
|
method: "PUT",
|
|
url: "/singer.SmartTrackService/ModifyTrackImg",
|
|
data: {
|
|
images,
|
|
smartTrackId
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.log("err", err);
|
|
}
|
|
};
|
|
var modifyTrackConf = async (conf, smartTrackId) => {
|
|
try {
|
|
await (0, import_request.default)({
|
|
method: "PUT",
|
|
url: "/singer.SmartTrackService/ModifyTrackConf",
|
|
data: {
|
|
conf,
|
|
smartTrackId
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.log("err", err);
|
|
}
|
|
};
|
|
var getTrackTaskById = async (smartTrackId = 0) => {
|
|
try {
|
|
const data = smartTrackId ? {
|
|
smartTrackId
|
|
} : {};
|
|
let req = await (0, import_request.default)({
|
|
method: "POST",
|
|
url: "/singer.SmartTrackService/GetSmartTrack",
|
|
data
|
|
});
|
|
return req;
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
};
|
|
var getTackDetailInfo = async (smartTrackId = 0) => {
|
|
const data = smartTrackId ? {
|
|
smartTrackId
|
|
} : {};
|
|
let req = await (0, import_request.default)({
|
|
method: "POST",
|
|
url: "/singer.SmartTrackService/GetTrackOverView",
|
|
data
|
|
});
|
|
return req;
|
|
};
|
|
var getTaskCameraByCenterAndPower = async (value) => {
|
|
let realCameraInfos = value["cameraInfos"];
|
|
let realPreprocessInfos = [];
|
|
if (!(0, import_func.isEmpty)(realCameraInfos)) {
|
|
const { taskStatus } = await (0, import_useTaskState.getListTaskStatus)();
|
|
realPreprocessInfos = (0, import_useTaskState.getCameraStatusFunc)(taskStatus);
|
|
}
|
|
const runRealCameraInfos = [];
|
|
realCameraInfos = realCameraInfos.filter((v) => {
|
|
if (import_Tree.default.judgeOccupyPowerById(v["id"], realPreprocessInfos)) {
|
|
runRealCameraInfos.push(v);
|
|
}
|
|
return !import_Tree.default.judgeOccupyPowerById(v["id"], realPreprocessInfos);
|
|
});
|
|
let from = turf.point(value["center"]);
|
|
if (realCameraInfos.length > value["taskPower"]["bodyPower"]) {
|
|
realCameraInfos.map((v) => {
|
|
let dis = turf.distance(from, turf.point([v["longitude"], v["latitude"]]));
|
|
return {
|
|
...v,
|
|
dis
|
|
};
|
|
}).sort((a, b) => {
|
|
return a - b;
|
|
});
|
|
realCameraInfos = realCameraInfos.slice(0, value["taskPower"]["bodyPower"]);
|
|
}
|
|
return [...runRealCameraInfos, ...realCameraInfos];
|
|
};
|
|
var createIntelligentTrack = async (value) => {
|
|
const data = {
|
|
images: value["images"],
|
|
type: value["model"],
|
|
normalComputerPower: value["bodyPower"] || 0,
|
|
faceComputerPower: value["facePower"] || 0,
|
|
// deviceIds: ['129537'],
|
|
deviceIds: value["deviceIds"],
|
|
conf: {
|
|
faceThreshold: defaultFaceThreshold,
|
|
bodyThreshold: defaultBodyThreshold,
|
|
faceResultNum: defaultFaceResultNum,
|
|
radius: value["circleRadius"] * 1e3,
|
|
queryCycle: defaultQueryCycle
|
|
},
|
|
centerConf: {
|
|
centerX: value["circleCenter"][0],
|
|
centerY: value["circleCenter"][1]
|
|
}
|
|
};
|
|
const res = await (0, import_request.default)({
|
|
method: "PUT",
|
|
url: "/singer.SmartTrackService/CreateSmartTrack",
|
|
data
|
|
});
|
|
return res;
|
|
};
|
|
var emitHeartbeat = async (smartTrackId) => {
|
|
try {
|
|
await (0, import_request.default)({
|
|
method: "POST",
|
|
url: "/singer.SmartTrackService/SmartTrackHeartBeat",
|
|
data: {
|
|
smartTrackId
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
};
|
|
var ModifyTrackCameras = async (value) => {
|
|
try {
|
|
await setIntelligentTrackCircleInfo(value["smartTrackId"], value["centerPoint"]);
|
|
await (0, import_request.default)({
|
|
url: "/singer.SmartTrackService/ModifyTrackCameras",
|
|
method: "PUT",
|
|
data: {
|
|
smartTrackId: value["smartTrackId"],
|
|
deviceIds: value["deviceIds"]
|
|
}
|
|
});
|
|
} catch (err) {
|
|
import_meta.message.error(err);
|
|
}
|
|
};
|
|
var setIntelligentTrackCircleInfo = async (smartTrackId, circleCenter) => {
|
|
try {
|
|
await (0, import_request.default)({
|
|
url: "/singer.SmartTrackService/ModifyTrackScopeConf",
|
|
method: "PUT",
|
|
data: {
|
|
smartTrackId,
|
|
centerConf: {
|
|
centerX: (0, import_func.get)(circleCenter, "0"),
|
|
centerY: (0, import_func.get)(circleCenter, "1")
|
|
}
|
|
}
|
|
});
|
|
} catch (err) {
|
|
import_meta.message.error(err);
|
|
}
|
|
};
|
|
var getTackCameraInfo = async (value) => {
|
|
let circleCameraInfos = await getCameraInfoByCircle(
|
|
value["circleCenter"],
|
|
value["radius"],
|
|
value["zoom"]
|
|
);
|
|
return circleCameraInfos;
|
|
};
|
|
var getCameraInfoByCircle = async (circleCenter, radius, zoom = 16) => {
|
|
try {
|
|
let centerFeature = turf.circle(turf.point(circleCenter), radius, {
|
|
units: "kilometers",
|
|
steps: 64
|
|
});
|
|
let minx = 0;
|
|
let maxx = 0;
|
|
let miny = 0;
|
|
let maxy = 0;
|
|
for (let i = 0; i < 4; i++) {
|
|
let point2 = turf.destination(turf.point(circleCenter), radius, 90 * i, {
|
|
units: "kilometers"
|
|
}).geometry.coordinates;
|
|
if (point2[0] < minx || minx === 0) {
|
|
minx = point2[0];
|
|
}
|
|
if (point2[0] > maxx || maxx === 0) {
|
|
maxx = point2[0];
|
|
}
|
|
if (point2[1] < miny || miny === 0) {
|
|
miny = point2[1];
|
|
}
|
|
if (point2[1] > maxy || maxy === 0) {
|
|
maxy = point2[1];
|
|
}
|
|
}
|
|
let { clusterPoint } = await (0, import_request.default)({
|
|
url: "/singer.DeviceService/GetClusters",
|
|
method: "POST",
|
|
data: {
|
|
northEast: { X: maxx, Y: maxy },
|
|
southWest: { X: minx, Y: miny },
|
|
zoom
|
|
}
|
|
});
|
|
let cameraIds = [];
|
|
clusterPoint.forEach((v) => {
|
|
cameraIds.push(...v["cameraIDs"]);
|
|
});
|
|
const { cameras } = await (0, import_utils.SearchCamera)({
|
|
cameraId: cameraIds,
|
|
maxResults: cameraIds.length
|
|
});
|
|
const cameraInfos = cameras.filter((v) => {
|
|
let cameraPoint = turf.point([(0, import_func.get)(v, "longitude"), (0, import_func.get)(v, "latitude")]);
|
|
return turf.booleanPointInPolygon(cameraPoint, centerFeature);
|
|
});
|
|
return cameraInfos;
|
|
} catch (err) {
|
|
console.error(err);
|
|
return [];
|
|
}
|
|
};
|
|
var taskInfoToSearchItem = (taskInfo) => {
|
|
let imageList = [];
|
|
(0, import_func.get)(taskInfo, "images", []).forEach((v) => {
|
|
const url = (0, import_func.get)(v, "conds.0.srcImageUrl");
|
|
const objectId = (0, import_func.get)(v, "conds.0.featureInfo.objectId");
|
|
let imageItem = {
|
|
index: 0,
|
|
url,
|
|
objectId,
|
|
odRects: (0, import_func.get)(v, "conds").map((item) => {
|
|
return {
|
|
fileKey: (0, import_func.get)(item, "objectImageUrl"),
|
|
extendRect: {
|
|
algorithmVersion: (0, import_func.get)(item, "alg", ""),
|
|
...(0, import_func.get)(item, "rect", {})
|
|
},
|
|
rect: {
|
|
algorithmVersion: (0, import_func.get)(item, "alg", ""),
|
|
rect: (0, import_func.get)(item, "rect", {})
|
|
}
|
|
};
|
|
})
|
|
};
|
|
imageList.push(imageItem);
|
|
});
|
|
return imageList;
|
|
};
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
ModifyTrackCameras,
|
|
createIntelligentTrack,
|
|
deleteTrackById,
|
|
emitHeartbeat,
|
|
getCameraInfoByCircle,
|
|
getDefaultRadius,
|
|
getSearchIntervalDuration,
|
|
getTackCameraInfo,
|
|
getTackDetailInfo,
|
|
getTaskCameraByCenterAndPower,
|
|
getTrackTaskById,
|
|
modifyTrackConf,
|
|
modifyTrackImgs,
|
|
operateTrackById,
|
|
setDefaultRadius,
|
|
setIntelligentTrackCircleInfo,
|
|
setSearchIntervalDuration,
|
|
taskInfoToSearchItem
|
|
});
|