backend/src/main/java/ru/diplom/vision/service/ReferenceImageService.java - master - Sturon/Diplom

backend/src/main/java/ru/diplom/vision/service/ReferenceImageService.java
128 строк5 KB
Sturon
Initial
03 июн 2026, 15:01
03 июн 2026, 15:0117b44a2
package ru.diplom.vision.service;

import java.util.List;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.server.ResponseStatusException;
import ru.diplom.vision.api.dto.RoiRequest;
import ru.diplom.vision.api.dto.RoiZoneRequest;
import ru.diplom.vision.domain.ReferenceImage;
import ru.diplom.vision.domain.RegionOfInterest;
import ru.diplom.vision.repository.InspectionProfileRepository;
import ru.diplom.vision.repository.ReferenceImageRepository;
import static org.springframework.http.HttpStatus.BAD_REQUEST;
import static org.springframework.http.HttpStatus.NOT_FOUND;

@Service
@Transactional
public class ReferenceImageService {

    private final ReferenceImageRepository referenceImageRepository;
    private final InspectionProfileRepository inspectionProfileRepository;
    private final StorageService storageService;

    public ReferenceImageService(
            ReferenceImageRepository referenceImageRepository,
            InspectionProfileRepository inspectionProfileRepository,
            StorageService storageService
    ) {
        this.referenceImageRepository = referenceImageRepository;
        this.inspectionProfileRepository = inspectionProfileRepository;
        this.storageService = storageService;
    }

    @Transactional(readOnly = true)
    public List<ReferenceImage> findAll() {
        List<ReferenceImage> referenceImages = referenceImageRepository.findAllByOrderByCreatedAtDesc();
        referenceImages.forEach(this::migrateLegacyRoiIfNeeded);
        return referenceImages;
    }

    @Transactional(readOnly = true)
    public ReferenceImage getRequired(Long id) {
        ReferenceImage referenceImage = referenceImageRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(NOT_FOUND, "Эталонное изображение не найдено"));
        migrateLegacyRoiIfNeeded(referenceImage);
        return referenceImage;
    }

    public ReferenceImage create(String name, MultipartFile file) {
        String actualName = (name == null || name.isBlank()) ? file.getOriginalFilename() : name;
        StorageService.StoredFileDescriptor storedFile = storageService.storeUploadedImage(
                "reference-images",
                file,
                actualName
        );

        ReferenceImage referenceImage = new ReferenceImage();
        referenceImage.setName(actualName == null ? "Эталон" : actualName.trim());
        referenceImage.setStoragePath(storedFile.relativePath());
        referenceImage.setMimeType(storedFile.mimeType());
        referenceImage.setWidth(storedFile.width());
        referenceImage.setHeight(storedFile.height());
        return referenceImageRepository.save(referenceImage);
    }

    public ReferenceImage updateRoi(Long id, RoiRequest request) {
        ReferenceImage referenceImage = getRequired(id);
        referenceImage.clearRegionsOfInterest();
        referenceImage.setRegionOfInterest(null);

        List<RoiZoneRequest> zones = request.rois() == null ? List.of() : request.rois();
        for (int index = 0; index < zones.size(); index++) {
            RoiZoneRequest zoneRequest = zones.get(index);
            validateRoi(referenceImage, zoneRequest);

            RegionOfInterest roi = new RegionOfInterest();
            roi.setName(zoneRequest.name().trim());
            roi.setZoneOrder(index);
            roi.setX(zoneRequest.x());
            roi.setY(zoneRequest.y());
            roi.setWidth(zoneRequest.width());
            roi.setHeight(zoneRequest.height());
            referenceImage.addRegionOfInterest(roi);
        }
        return referenceImageRepository.save(referenceImage);
    }

    public void delete(Long id) {
        if (inspectionProfileRepository.countByReferenceImageId(id) > 0) {
            throw new ResponseStatusException(BAD_REQUEST, "Эталон используется в точках контроля");
        }

        ReferenceImage referenceImage = getRequired(id);
        storageService.delete(referenceImage.getStoragePath());
        referenceImageRepository.delete(referenceImage);
    }

    public List<RegionOfInterest> getEffectiveRegionsOfInterest(ReferenceImage referenceImage) {
        migrateLegacyRoiIfNeeded(referenceImage);
        return referenceImage.getRegionsOfInterest();
    }

    private void migrateLegacyRoiIfNeeded(ReferenceImage referenceImage) {
        if (!referenceImage.getRegionsOfInterest().isEmpty() || referenceImage.getRegionOfInterest() == null) {
            return;
        }

        RegionOfInterest legacyRoi = referenceImage.getRegionOfInterest();
        RegionOfInterest migratedRoi = new RegionOfInterest();
        migratedRoi.setName("Зона 1");
        migratedRoi.setZoneOrder(0);
        migratedRoi.setX(legacyRoi.getX());
        migratedRoi.setY(legacyRoi.getY());
        migratedRoi.setWidth(legacyRoi.getWidth());
        migratedRoi.setHeight(legacyRoi.getHeight());

        referenceImage.setRegionOfInterest(null);
        referenceImage.addRegionOfInterest(migratedRoi);
    }

    private void validateRoi(ReferenceImage referenceImage, RoiZoneRequest request) {
        if (request.x() + request.width() > referenceImage.getWidth()
                || request.y() + request.height() > referenceImage.getHeight()) {
            throw new ResponseStatusException(BAD_REQUEST, "ROI выходит за границы изображения");
        }
    }
}