endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/prediction/video_prediction_meta.py

@@ -0,0 +1,306 @@
+from typing import Union, TYPE_CHECKING
+from django.db import models
+
+from endoreg_db.models.label.label import LabelSet
+from ..data_file.video import Video
+from ..data_file.import_classes import RawVideoFile
+from ..data_file.frame import Frame
+from .image_classification import ImageClassificationPrediction
+from ..data_file import (
+    LabelVideoSegment,
+    find_segments_in_prediction_array,
+)
+
+# from ..information_source import get_prediction_information_source
+import numpy as np
+import pickle
+
+DEFAULT_WINDOW_SIZE_IN_SECONDS_FOR_RUNNING_MEAN = 1.5
+DEFAULT_VIDEO_SEGMENT_LENGTH_THRESHOLD_IN_S = 1.0
+
+if TYPE_CHECKING:
+    from endoreg_db.models import ModelMeta
+
+
+class AbstractVideoPredictionMeta(models.Model):
+    model_meta = models.ForeignKey("ModelMeta", on_delete=models.CASCADE)
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+    video = None  # Placeholder for the video field, to be defined in derived classes
+    prediction_array = models.BinaryField(blank=True, null=True)
+    is_raw = models.BooleanField(default=False)
+
+    if TYPE_CHECKING:
+        model_meta: "ModelMeta"
+        video: Union["Video", "RawVideoFile"]
+
+    class Meta:
+        abstract = True
+        unique_together = ("model_meta", "video")
+
+    def is_raw_video_prediction_meta(self):
+        if isinstance(self, RawVideoPredictionMeta):
+            return True
+        return False
+
+    def __str__(self):
+        return f"Video {self.video.id} - {self.model_meta.name}"
+
+    # override save method to set is_raw field
+    def save(self, *args, **kwargs):
+        self.is_raw = self.is_raw_video_prediction_meta()
+        super().save(*args, **kwargs)
+
+    def get_labelset(self):
+        """
+        Get the labelset of the predictions.
+        """
+        if self.is_raw:
+            return self.model_meta.labelset
+
+    def get_video_model(self):
+        if self.is_raw:
+            return RawVideoFile
+
+        return Video
+
+    def get_frame_model(self):
+        return Frame
+
+    def get_video_segment_model(self):
+        from endoreg_db.models import LabelRawVideoSegment
+
+        if self.is_raw:
+            return LabelRawVideoSegment
+        return LabelVideoSegment
+
+    def get_label_list(self):
+        """
+        Get the label list of the predictions.
+        """
+        labelset: LabelSet = self.get_labelset()
+        label_list = labelset.get_labels_in_order()
+        return label_list
+
+    def save_prediction_array(self, prediction_array: np.array):
+        """
+        Save the prediction array to the database.
+        """
+        self.prediction_array = pickle.dumps(prediction_array)
+        self.save()
+
+    def get_prediction_array(self):
+        """
+        Get the prediction array from the database.
+        """
+        if self.prediction_array is None:
+            return None
+        else:
+            return pickle.loads(self.prediction_array)
+
+    def calculate_prediction_array(self):
+        assert 1 == 2, "This method should be overridden in derived classes"
+
+    def apply_running_mean(self, confidence_array, window_size_in_seconds: int = None):
+        """
+        Apply a running mean filter to the confidence array for smoothing, assuming a padding
+        of 0.5 for the edges.
+
+        Args:
+        self: Object that has video and fps attributes, and to which this function belongs.
+        confidence_array: A 2D numpy array with dimensions (num_frames),
+                        containing confidence scores for each label at each frame.
+        window_size_in_seconds: The window size for the running mean in seconds.
+
+        Returns:
+        running_mean_array: A 2D numpy array with the same dimensions as confidence_array,
+                            containing the smoothed confidence scores.
+        """
+        video = self.video
+        fps = video.fps
+
+        if not window_size_in_seconds:
+            window_size_in_seconds = DEFAULT_WINDOW_SIZE_IN_SECONDS_FOR_RUNNING_MEAN
+
+        # Calculate window size in frames, ensuring at least one frame
+        window_size_in_frames = int(window_size_in_seconds * fps)
+        window_size_in_frames = max(window_size_in_frames, 1)
+
+        # Define the window for the running mean
+        window = np.ones(window_size_in_frames) / window_size_in_frames
+
+        # Create running mean array with the same shape as the confidence array
+        _running_mean_array = np.zeros(confidence_array.shape)
+
+        # Calculate the padding size
+        pad_size = window_size_in_frames // 2
+
+        # Pad the array with 0.5 on both sides
+        padded_confidences = np.pad(
+            confidence_array,
+            (pad_size, pad_size),
+            "constant",
+            constant_values=(0.5, 0.5),
+        )
+
+        # Apply the running mean filter on the padded array
+        running_mean = np.convolve(padded_confidences, window, mode="same")
+
+        # Remove the padding from the result to match the original shape
+        running_mean = running_mean[pad_size:-pad_size]
+
+        return running_mean
+
+    # FIXME
+    # def create_video_segments_for_label(self, segments, label):
+    #     """
+    #     Creates video segments for the given label and segments.
+    #     Segments is a list of tuples (start_frame_number, end_frame_number).
+    #     Labels is a Label object.
+    #     """
+    #     video = self.video
+    #     video_segment_model = self.get_video_segment_model()
+    #     information_source = get_prediction_information_source()
+
+    #     for segment in segments:
+    #         start_frame_number, end_frame_number = segment
+
+    #         video_segment = video_segment_model(
+    #             video=video,
+    #             prediction_meta=self,
+    #             start_frame_number=start_frame_number,
+    #             end_frame_number=end_frame_number,
+    #             source=information_source,
+    #             label=label,
+    #         )
+    #         video_segment.save()
+
+    def create_video_segments(self, segment_length_threshold_in_s: float = None):
+        if not segment_length_threshold_in_s:
+            segment_length_threshold_in_s = DEFAULT_VIDEO_SEGMENT_LENGTH_THRESHOLD_IN_S
+
+        video = self.video
+        fps = video.fps
+        min_frame_length = int(segment_length_threshold_in_s * fps)
+
+        label_list = self.get_label_list()
+
+        # if prediction array doesnt exist, create it
+        if self.prediction_array is None:
+            self.calculate_prediction_array()
+
+        prediction_array = self.get_prediction_array()
+
+        for i, label in enumerate(label_list):
+            # get predictions for this label
+            predictions = prediction_array[:, i]
+            # find segments of predictions that are longer than the threshold
+            # segments is a list of tuples (start_frame_number, end_frame_number)
+            segments = find_segments_in_prediction_array(predictions, min_frame_length)
+
+            # create video segments
+            self.create_video_segments_for_label(segments, label)
+
+
+class RawVideoPredictionMeta(AbstractVideoPredictionMeta):
+    """
+    Model for storing video predictions for a specific model and video.
+    """
+
+    video = models.ForeignKey(
+        "RawVideoFile", on_delete=models.CASCADE, related_name="video_prediction_meta"
+    )
+
+    def calculate_prediction_array(self, window_size_in_seconds: int = None):
+        """
+        Fetches all predictions for this video, labelset, and model meta.
+        """
+        video: Video = self.video
+
+        model_meta = self.model_meta
+        label_list = self.get_label_list()
+
+        prediction_array = np.zeros((video.get_frame_number, len(label_list)))
+        for i, label in enumerate(label_list):
+            # fetch all predictions for this label, video, and model meta ordered by ImageClassificationPrediction.frame.frame_number
+            predictions = ImageClassificationPrediction.objects.filter(
+                label=label, frame__video=video, model_meta=model_meta
+            ).order_by("frame__frame_number")
+            confidences = np.array(
+                [prediction.confidence for prediction in predictions]
+            )
+            smooth_confidences = self.apply_running_mean(
+                confidences, window_size_in_seconds
+            )
+            # calculate binary predictions
+            binary_predictions = smooth_confidences > 0.5
+            # add to prediction array
+            prediction_array[:, i] = binary_predictions
+
+        # save prediction array
+        self.save_prediction_array(prediction_array)
+
+
+class VideoPredictionMeta(AbstractVideoPredictionMeta):
+    """
+    Model for storing video predictions for a specific model and video.
+    """
+
+    video = models.ForeignKey(
+        "Video", on_delete=models.CASCADE, related_name="video_prediction_meta"
+    )
+
+    @classmethod
+    def from_raw(
+        cls, video: "Video", raw_video_prediction_meta: RawVideoPredictionMeta
+    ):
+        """
+        Create a new VideoPrediction from an existing RawVideoPredictionMeta.
+        """
+        cls_dict = {
+            "video": video,
+            "model_meta": raw_video_prediction_meta.model_meta,
+            "date_created": raw_video_prediction_meta.date_created,
+            "date_modified": raw_video_prediction_meta.date_modified,
+            "prediction_array": raw_video_prediction_meta.prediction_array,
+            "is_raw": False,
+        }
+
+        # check if exists
+        if cls.objects.filter(
+            video=video, model_meta=raw_video_prediction_meta.model_meta
+        ).exists():
+            return cls.objects.get(
+                video=video, model_meta=raw_video_prediction_meta.model_meta
+            )
+        else:
+            return cls.objects.create(**cls_dict)
+
+    def calculate_prediction_array(self, window_size_in_seconds: int = None):
+        """
+        Fetches all predictions for this video, labelset, and model meta.
+        """
+        video: Video = self.video
+
+        model_meta = self.model_meta
+        label_list = self.get_label_list()
+
+        prediction_array = np.zeros((video.get_frame_number, len(label_list)))
+        for i, label in enumerate(label_list):
+            # fetch all predictions for this label, video, and model meta ordered by ImageClassificationPrediction.frame.frame_number
+            predictions = ImageClassificationPrediction.objects.filter(
+                label=label, frame__video=video, model_meta=model_meta
+            ).order_by("frame__frame_number")
+            confidences = np.array(
+                [prediction.confidence for prediction in predictions]
+            )
+            smooth_confidences = self.apply_running_mean(
+                confidences, window_size_in_seconds
+            )
+            # calculate binary predictions
+            binary_predictions = smooth_confidences > 0.5
+            # add to prediction array
+            prediction_array[:, i] = binary_predictions
+
+        # save prediction array
+        self.save_prediction_array(prediction_array)

endoreg_db/models/product/__init__.py

@@ -0,0 +1,14 @@
+'''Module for product models'''
+from .product import Product
+from .product_material import ProductMaterial
+from .product_group import ProductGroup
+from .reference_product import ReferenceProduct
+from .product_weight import ProductWeight
+
+__all__ = [
+    'Product',
+    'ProductMaterial',
+    'ProductGroup',
+    'ReferenceProduct',
+    'ProductWeight',
+]

endoreg_db/models/product/product.py

@@ -0,0 +1,110 @@
+from django.db import models
+
+class ProductManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+def sum_weights(product_materials):
+    # sum up the weights
+    weight = 0
+    reference_unit = None
+    for product_material in product_materials:
+        if not reference_unit:
+            reference_unit = product_material.unit
+        else:
+            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+        weight += product_material.quantity
+
+    return weight, reference_unit
+
+def sum_emissions(product_materials):
+    # sum up the emissions
+    emission = 0
+    reference_unit = None
+    for product_material in product_materials:
+        if not reference_unit:
+            reference_unit = product_material.unit
+        else:
+            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+        emission, emission_unit = product_material.get_emission()
+        assert reference_unit == emission_unit, "ProductMaterial units do not match"
+        emission += emission
+
+    return emission, reference_unit
+
+class Product(models.Model):
+    objects = ProductManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+
+    transport_route = models.ForeignKey("TransportRoute", on_delete=models.SET_NULL, null=True)
+    product_group = models.ForeignKey(
+        "ProductGroup", on_delete=models.SET_NULL, null=True
+    )
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        result = f"{self.name}"
+        if self.product_group:
+            result += f" ({self.product_group}, "
+        else:
+            result += " (no product group, "
+
+        if self.transport_route:
+            result += f"{self.transport_route})"
+        else:
+            result += "no transport route)"
+        
+        return result
+    
+    def get_product_weight(self):
+        # check if there is a product material weight
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+        if product_materials:
+            return self.get_product_material_weight()
+        
+        # check if there is a product weight
+        #TODO
+
+    def get_package_weight(self):
+        # check if there is a package material weight
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+        if product_materials:
+            return self.get_package_material_weight()
+        
+        # check if there is a package weight
+        #TODO
+
+    def get_product_material_weight(self):
+        # get all materials with component == "product"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+
+        return sum_weights(product_materials)
+    
+    def get_package_material_weight(self):
+        # get all materials with component == "package"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+
+        return sum_weights(product_materials)
+
+    def get_product_material_emission(self):
+        # get all materials with component == "product"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+
+        return sum_emissions(product_materials)
+
+    def get_package_material_emission(self):
+        # get all materials with component == "package"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+
+        return sum_emissions(product_materials)

endoreg_db/models/product/product_group.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+class ProductGroupManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ProductGroup(models.Model):
+    objects = ProductGroupManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_products(self):
+        from endoreg_db.models import Product
+        return Product.objects.filter(product_group=self)
+    
+    def get_reference_product(self):
+        from endoreg_db.models import ReferenceProduct
+        return ReferenceProduct.objects.get(product_group=self)
+    

endoreg_db/models/product/product_material.py

@@ -0,0 +1,28 @@
+from django.db import models
+
+class ProductMaterial(models.Model):
+    component = models.CharField(max_length=255)
+    material = models.ForeignKey("Material", on_delete=models.CASCADE)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE, related_name="product_materials")
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    quantity = models.FloatField()
+
+    def get_emission(self):
+        from ..emission import EmissionFactor
+        emission_factor:EmissionFactor = self.material.emission_factor
+        if emission_factor is None:
+            raise Exception("No emission factor for material " + self.material.name + " found.")
+        
+        # make sure product_material.unit is the same as emission_factor.unit
+        if self.unit != emission_factor.unit:
+            raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
+        
+        emmision_value = emission_factor.value * self.quantity
+        emission_unit = emission_factor.unit
+        return emmision_value, emission_unit
+    
+    def __str__(self):
+        return f"{self.product.name} - {self.material.name} - {self.quantity} {self.unit.name}"
+    
+        
+

endoreg_db/models/product/product_weight.py

@@ -0,0 +1,38 @@
+from django.db import models
+import pandas as pd
+
+class ProductWeightManager(models.Manager):
+    def get_by_natural_key(self, product, product_group, weight):
+        return self.get(product=product, product_group=product_group, weight=weight)
+    
+class ProductWeight(models.Model):
+    objects = ProductWeightManager()
+
+    name = models.CharField(max_length=255, null = True)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    measured = models.FloatField(null=True)
+    verified = models.FloatField(null=True)
+    manufacturer = models.FloatField(null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    def get_weight(self):
+        if not pd.isnull(self.verified):
+            return self.verified
+        elif not pd.isnull(self.measured):
+            return self.measured
+        elif not pd.isnull(self.manufacturer):
+            return self.manufacturer
+        else:
+            return None
+        
+    def get_weight_source(self):
+        if not pd.isnull(self.verified):
+            return "verified"
+        elif not pd.isnull(self.measured):
+            return "measured"
+        elif not pd.isnull(self.manufacturer):
+            return "manufacturer"
+        else:
+            return None
+    def __str__(self):
+        return f"{self.product} - {self.get_weight()} {self.unit} (Source: {self.get_weight_source()})"

endoreg_db/models/product/reference_product.py

@@ -0,0 +1,115 @@
+from django.db import models
+from typing import List
+
+class ReferenceProductManager(models.Manager):
+    def get_by_natural_key(self, product_name:str, product_group_name:str):
+        return self.get(product__name=product_name, product_group__name=product_group_name)
+
+class ReferenceProduct(models.Model):
+    name = models.CharField(max_length=255)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    product_group = models.OneToOneField("ProductGroup", on_delete=models.CASCADE, related_name="reference_product")
+    emission_factor_total = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank = True,
+        # related_name="reference_product_total"
+        )
+    emission_factor_package = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        related_name="reference_product_package"
+    )
+    emission_factor_product = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        related_name="reference_product_product"
+    )
+    
+    objects = ReferenceProductManager()
+
+    def __str__(self):
+        return self.product.name + " (" + self.product_group.name + ")"
+    
+    def set_emission_factors(self):
+        from .product import Product
+        from .product_material import ProductMaterial
+        from ..emission import EmissionFactor
+
+        product:Product = self.product
+        materials = product.product_materials.all()
+        emission_factor_name = f"{self.product_group.name}_{product.name}_total_emission_factor"
+        emission_factor_package_name = f"{self.product_group.name}_{product.name}_package_emission_factor"
+        emission_factor_product_name = f"{self.product_group.name}_{product.name}_product_emission_factor"
+
+        product_emissions = 0
+        package_emissions = 0
+
+        product_weight, product_weight_unit = product.get_product_material_weight()
+        package_weight, package_weight_unit = product.get_package_material_weight()
+        product_emission, product_emission_unit = product.get_product_material_emission()
+        package_emission, package_emission_unit = product.get_package_material_emission()
+
+        total_weight = product_weight + package_weight
+        total_emission = product_emission + package_emission
+
+        reference_unit = product_weight_unit
+        assert reference_unit == package_weight_unit, "Package weight units do not match"
+        assert reference_unit == product_emission_unit, "Product emission units do not match"
+        assert reference_unit == package_emission_unit, "Package emission units do not match"
+
+        product_emission_factor_value = product_emission / product_weight
+        package_emission_factor_value = package_emission / package_weight
+        total_emission_factor_value = total_emission / total_weight
+
+        emission_factor, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_name,
+            defaults={
+                "name": emission_factor_name,
+                "value": total_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_total = emission_factor
+
+        emission_factor_package, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_package_name,
+            defaults={
+                "name": emission_factor_package_name,
+                "value": package_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_package = emission_factor_package
+
+        emission_factor_product, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_product_name,
+            defaults={
+                "name": emission_factor_product_name,
+                "value": product_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_product = emission_factor_product
+
+        self.save()
+
+    def get_emission_factor(self, component:str):
+        # check if emission_factor_total exists:
+        if self.emission_factor_total is None:
+            self.set_emission_factors()
+
+        if component == "total":
+            return self.emission_factor_total
+        elif component == "package":
+            return self.emission_factor_package
+        elif component == "product":
+            return self.emission_factor_product
+        else:
+            raise Exception("Unknown component: " + component)
+        
+
+