Python get_namespase_domain_smart_building 예제들

예제 #1

class PresenceToLunch(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add(
            (inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.CO2))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))  #Day
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Office_Room))

        co2ToLunchLength = self.MODELS['PresenceToLunchLength']
        self.graph.add(
            (co2ToLunchLength, self.RDF.type, self.PRIVVULN.PrivacyAttack))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], co2ToLunchLength))

        lunchLength = self.MODELS['Lunch_Length']
        self.graph.add((lunchLength, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((lunchLength, self.PRIVVULNV2.description,
                        Literal("Lunch length", datatype=self.XSD.string)))
        self.graph.add((co2ToLunchLength, self.PRIVVULN.creates, lunchLength))
        self.graph.add((lunchLength, self.PRIVVULNV2.privacyRiskScore,
                        Literal("1", datatype=self.XSD.int)))

예제 #2

파일: OccupantIdentity.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class WalkingEventsToOccupantIdentity(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/3137133.3137154
        #DOI: 10.1145/2993422.2993429
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.WalkingEvents))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("0", datatype=self.XSD.double))) #Event
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))

        spatialResolution1 = self.MODELS['SpatialResolution1']
        self.graph.add((spatialResolution1, self.RDF.type, self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialInput, self.__DOMAINNAMESPACE__.Door))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialOutput, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution1))

        walkingEventsToOccupantIdentity = self.MODELS['WalkingEventsToOccupantIdentity']
        self.graph.add((walkingEventsToOccupantIdentity, self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], walkingEventsToOccupantIdentity))

        occupantIdentities = self.MODELS['OccupantIdentities']
        self.graph.add((occupantIdentities, self.RDF.type, self.__DOMAINNAMESPACE__.OccupantIdentity))
        self.graph.add((occupantIdentities, self.RDF.type, self.PRIVVULN.Metadata))
        self.graph.add((walkingEventsToOccupantIdentity, self.PRIVVULN['feeds'], occupantIdentities))

예제 #3

파일: PowerMeter.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class TimeTempAndCountsToPowerMeter(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/2993422.2993427
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.Timestamp))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Outside))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.Temperature))
        self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution,
                        Literal("300", datatype=self.XSD.double)))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Office_Room))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.OccupantCount))
        self.graph.add((inputNode3, self.PRIVVULNV2.TemporalResolution,
                        Literal("300", datatype=self.XSD.double)))
        self.graph.add((inputNode3, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Office_Room))

        timeTempAndCountsToSmartMeter = self.MODELS[
            'TimeTempAndCountsToSmartMeter']
        self.graph.add((timeTempAndCountsToSmartMeter, self.RDF.type,
                        self.PRIVVULN.Transformation))
        self.graph.add(
            (inputNode, self.PRIVVULN.feeds, timeTempAndCountsToSmartMeter))
        self.graph.add(
            (inputNode2, self.PRIVVULN.feeds, timeTempAndCountsToSmartMeter))
        self.graph.add(
            (inputNode3, self.PRIVVULN.feeds, timeTempAndCountsToSmartMeter))

        powerMeter = self.MODELS['PowerMeter']
        self.graph.add(
            (powerMeter, self.RDF.type, self.__DOMAINNAMESPACE__.PowerMeter))
        self.graph.add((timeTempAndCountsToSmartMeter, self.PRIVVULN['feeds'],
                        powerMeter))
        self.graph.add((powerMeter, self.RDF.type, self.PRIVVULN.TimeSeries))

예제 #4

파일: ContextIdentity.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class ContextLocationToFloorIdentity(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ContextLocation))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Floor))

        contextLocationToFloorIdentity = self.MODELS[
            'ContextLocationToFloorIdentity']
        self.graph.add((contextLocationToFloorIdentity, self.RDF.type,
                        self.PRIVVULN.PrivacyAttack))
        self.graph.add(
            (inputNode, self.PRIVVULN.feeds, contextLocationToFloorIdentity))

        contextIdentity = self.MODELS['ContextIdentity_Floor']
        self.graph.add(
            (contextIdentity, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((contextIdentity, self.PRIVVULNV2.description,
                        Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add((contextLocationToFloorIdentity, self.PRIVVULN.creates,
                        contextIdentity))
        self.graph.add((contextIdentity, self.PRIVVULNV2.privacyRiskScore,
                        Literal("1", datatype=self.XSD.int)))

예제 #5

class PresenceToWorkDays_Single_Office_Room(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.Presence))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("86400", datatype=self.XSD.double)))  #Day
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Single_Office_Room))

        presenceToWorkDays = self.MODELS['PresenceToWorkDays']
        self.graph.add(
            (presenceToWorkDays, self.RDF.type, self.PRIVVULN.PrivacyAttack))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], presenceToWorkDays))

        workday = self.MODELS['Work_day_Single_Office_Room']
        self.graph.add((workday, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((workday, self.PRIVVULNV2.description,
                        Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add((presenceToWorkDays, self.PRIVVULN.creates, workday))
        self.graph.add((workday, self.PRIVVULNV2.privacyRiskScore,
                        Literal("3", datatype=self.XSD.int)))

예제 #6

class OccupantActivitiesToOccupantNetworkRoom(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/3276774.3276779
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("3600", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Desk))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.OccupantActivities))

        spatialResolution1 = self.MODELS['SpatialResolution1']
        self.graph.add((spatialResolution1, self.RDF.type, self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialInput, self.__DOMAINNAMESPACE__.Desk))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialOutput, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution1))

        occupantActivitiesToOccupantNetwork = self.MODELS['OccupantActivitiesToOccupantNetworkRoom']
        self.graph.add((occupantActivitiesToOccupantNetwork, self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], occupantActivitiesToOccupantNetwork))

        occupantNetwork = self.MODELS['OccupantNetwork']
        self.graph.add((occupantNetwork, self.RDF.type, self.PRIVVULN.Graph))
        self.graph.add((occupantNetwork, self.RDF.type, self.__DOMAINNAMESPACE__.OccupantNetwork))
        self.graph.add((occupantActivitiesToOccupantNetwork, self.PRIVVULN.feeds, occupantNetwork))

예제 #7

class ChannelStateInformationToOccupantActivities(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #doi: 10.1145/3408308.3427624
        #doi: 10.1145/3408308.3427983
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("0.1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.ChannelStateInformation))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type, self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        channelStateInformationToOccupantActivities = self.MODELS['ChannelStateInformationToOccupantActivities']
        self.graph.add((channelStateInformationToOccupantActivities, self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], channelStateInformationToOccupantActivities))

        occupantActivities = self.MODELS['OccupantActivities']
        self.graph.add((occupantActivities, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((occupantActivities, self.RDF.type, self.__DOMAINNAMESPACE__.OccupantActivities))
        self.graph.add((channelStateInformationToOccupantActivities, self.PRIVVULN.feeds, occupantActivities))

예제 #8

class PlugloadToOccupantActivitiesDesk(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("3600", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Desk))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.PowerMeter))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type, self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        plugloadToOccupantActivitiesDesk = self.MODELS['PlugloadToOccupantActivitiesDesk']
        self.graph.add((plugloadToOccupantActivitiesDesk, self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], plugloadToOccupantActivitiesDesk))

        occupantActivities = self.MODELS['OccupantActivities']
        self.graph.add((occupantActivities, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((occupantActivities, self.RDF.type, self.__DOMAINNAMESPACE__.OccupantActivities))
        self.graph.add((plugloadToOccupantActivitiesDesk, self.PRIVVULN.feeds, occupantActivities))

예제 #9

파일: ContextIdentity.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class ContextLocationPresenceAndScheduleActivitiesToTeachingPerformance(
        IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ContextLocation))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Teaching_Room))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ScheduleActivities))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Teaching_Room))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULNV2.TemporalResolution,
                        Literal("900", datatype=self.XSD.double)))
        self.graph.add((inputNode3, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.Presence))
        self.graph.add((inputNode3, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Teaching_Room))

        contextLocationPresenceAndScheduleActivitiesToTeachingPerformance = self.MODELS[
            'ContextLocationPresenceAndScheduleActivitiesToTeachingPerformance']
        self.graph.add(
            (contextLocationPresenceAndScheduleActivitiesToTeachingPerformance,
             self.RDF.type, self.PRIVVULN.PrivacyAttack))
        self.graph.add((
            inputNode, self.PRIVVULN.feeds,
            contextLocationPresenceAndScheduleActivitiesToTeachingPerformance))
        self.graph.add((
            inputNode2, self.PRIVVULN.feeds,
            contextLocationPresenceAndScheduleActivitiesToTeachingPerformance))
        self.graph.add((
            inputNode3, self.PRIVVULN.feeds,
            contextLocationPresenceAndScheduleActivitiesToTeachingPerformance))

        teachingPerformance = self.MODELS[
            'Teaching_Performance_based_On_Presence']
        self.graph.add(
            (teachingPerformance, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((teachingPerformance, self.PRIVVULNV2.description,
                        Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add(
            (contextLocationPresenceAndScheduleActivitiesToTeachingPerformance,
             self.PRIVVULN.creates, teachingPerformance))
        self.graph.add((teachingPerformance, self.PRIVVULNV2.privacyRiskScore,
                        Literal("1", datatype=self.XSD.int)))

예제 #10

파일: ContextLocation.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class ContextLocationOccupantCountAndScheduleActivitiesToRoomIdentity(
        ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("900", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.OccupantCount))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ScheduleActivities))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode3, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode3, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ContextLocation))

        contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity = self.MODELS[
            'ContextLocationOccupantCountAndScheduleActivitiesToRoomIdentity']
        self.graph.add(
            (contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity,
             self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add(
            (inputNode, self.PRIVVULN['feeds'],
             contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity))
        self.graph.add(
            (inputNode2, self.PRIVVULN['feeds'],
             contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity))
        self.graph.add(
            (inputNode3, self.PRIVVULN['feeds'],
             contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity))

        contextIdentity = self.MODELS['ContextIdentity']
        self.graph.add(
            (contextIdentity, self.RDF.type, self.PRIVVULN.Metadata))
        self.graph.add((contextIdentity, self.RDF.type,
                        self.__DOMAINNAMESPACE__.ContextLocation))
        self.graph.add(
            (contextLocationOccupantCountAndScheduleActivitiesToRoomIdentity,
             self.PRIVVULN.feeds, contextIdentity))

예제 #11

class CountingLineToPresence(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("300", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.CountingLine))

        countingLineToPresence = self.MODELS['CountingLineToPresence']
        self.graph.add((countingLineToPresence, self.RDF.type,
                        self.PRIVVULN.Transformation))
        self.graph.add(
            (inputNode, self.PRIVVULN['feeds'], countingLineToPresence))

        # spatialResolution1 = self.MODELS['SpatialResolution1']
        # self.graph.add((spatialResolution1, self.RDF.type, self.PRIVVULNV2.SpatialResolution))
        # self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialInput, self.__DOMAINNAMESPACE__.Room))
        # self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialOutput, self.__DOMAINNAMESPACE__.Room))
        # self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution1))

        # spatialResolution2 = self.MODELS['SpatialResolution2']
        # self.graph.add((spatialResolution2, self.RDF.type, self.PRIVVULNV2.SpatialResolution))
        # self.graph.add((spatialResolution2, self.PRIVVULNV2.spatialInput, self.__DOMAINNAMESPACE__.Teaching_Room))
        # self.graph.add((spatialResolution2, self.PRIVVULNV2.spatialOutput, self.__DOMAINNAMESPACE__.Teaching_Room))
        # self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution2))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        presenceStream = self.MODELS['PresenceStream']
        self.graph.add(
            (presenceStream, self.RDF.type, self.__DOMAINNAMESPACE__.Presence))
        self.graph.add(
            (countingLineToPresence, self.PRIVVULN['feeds'], presenceStream))
        self.graph.add(
            (presenceStream, self.RDF.type, self.PRIVVULN.TimeSeries))

예제 #12

파일: LimbMass.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class LimbMassLimbSurfaceAreaAndAverageBMIToWeight(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.LimbMass))
        # self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("450", datatype=self.XSD.double)))
        #Can be combined using a multiple sources, however, this makes the privacy score a bit geneal
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Space))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Wing))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.LimbSurfaceArea))
        # self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution, Literal("450", datatype=self.XSD.double)))
        #Can be combined using a multiple sources, however, this makes the privacy score a bit geneal
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Space))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Wing))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.AverageBMI))

        limbMassLimbSurfaceAreaAndAverageBMIToWeight = self.MODELS['LimbMassLimbSurfaceAreaAndAverageBMIToWeight']
        self.graph.add((limbMassLimbSurfaceAreaAndAverageBMIToWeight, self.RDF.type, self.PRIVVULN.PrivacyAttack))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], limbMassLimbSurfaceAreaAndAverageBMIToWeight))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'], limbMassLimbSurfaceAreaAndAverageBMIToWeight))
        self.graph.add((inputNode3, self.PRIVVULN['feeds'], limbMassLimbSurfaceAreaAndAverageBMIToWeight))

        weight = self.MODELS['Weight']
        self.graph.add((weight, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((weight, self.PRIVVULNV2.description, Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add((limbMassLimbSurfaceAreaAndAverageBMIToWeight, self.PRIVVULN.creates, weight))
        self.graph.add((weight, self.PRIVVULNV2.privacyRiskScore, Literal("3", datatype=self.XSD.int)))

예제 #13

class UltrasonicDistanceToWalkingEvents(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/3137133.3137154
        #DOI: 10.1145/2993422.2993429
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.UltrasonicDistance))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("0", datatype=self.XSD.double)))  #Event
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Door))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        ultrasonicDistanceToWalkingEvents = self.MODELS[
            'UltrasonicDistanceToWalkingEvents']
        self.graph.add((ultrasonicDistanceToWalkingEvents, self.RDF.type,
                        self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        ultrasonicDistanceToWalkingEvents))

        walkingEvents = self.MODELS['WalkingEvents']
        self.graph.add((walkingEvents, self.RDF.type,
                        self.__DOMAINNAMESPACE__.WalkingEvents))
        self.graph.add((ultrasonicDistanceToWalkingEvents,
                        self.PRIVVULN['feeds'], walkingEvents))
        self.graph.add(
            (walkingEvents, self.RDF.type, self.PRIVVULN.TimeSeries))

예제 #14

파일: LimbSurfaceArea.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class SkeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.SkeletonJoints))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.SkeletonModel))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.TypicalBodyShape))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type, self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput, Literal("1",datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea = self.MODELS['SkeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea']
        self.graph.add((skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea, self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'], skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea))
        self.graph.add((inputNode3, self.PRIVVULN['feeds'], skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea))

        limbSurfaceArea = self.MODELS['LimbSurfaceArea']
        self.graph.add((limbSurfaceArea, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((limbSurfaceArea, self.RDF.type, self.__DOMAINNAMESPACE__.LimbSurfaceArea))
        self.graph.add((skeletonJointsSkeletonModelAndTypicalBodyShapeToLimbSurfaceArea, self.PRIVVULN.feeds, limbSurfaceArea))

예제 #15

class PowerMeterToPresence(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("3600", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.PowerMeter))

        meanThresholdingDetectionForOccupied = self.MODELS[
            'MeanThresholdingDetectionForOccupied']
        self.graph.add((meanThresholdingDetectionForOccupied, self.RDF.type,
                        self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'],
                        meanThresholdingDetectionForOccupied))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        presenceStream = self.MODELS['PresenceStream']
        self.graph.add(
            (presenceStream, self.RDF.type, self.__DOMAINNAMESPACE__.Presence))
        self.graph.add((meanThresholdingDetectionForOccupied,
                        self.PRIVVULN['feeds'], presenceStream))
        self.graph.add(
            (presenceStream, self.RDF.type, self.PRIVVULN.TimeSeries))

예제 #16

파일: SocialRelation.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class OccupantNetworkToSocialRelationRoom(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/3276774.3276779
        self.MODELS =  Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.OccupantNetwork))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))

        occupantCountToOccupantActivities = self.MODELS['OccupantCountToOccupantActivities']
        self.graph.add((occupantCountToOccupantActivities, self.RDF.type, self.PRIVVULN.PrivacyAttack))
        self.graph.add((inputNode, self.PRIVVULN['feeds'], occupantCountToOccupantActivities))

        socialRelation = self.MODELS['SocialRelation']
        self.graph.add((socialRelation, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((socialRelation, self.PRIVVULNV2.description, Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add((occupantCountToOccupantActivities, self.PRIVVULN.creates, socialRelation))
        self.graph.add((socialRelation, self.PRIVVULNV2.privacyRiskScore, Literal("3", datatype=self.XSD.int)))

예제 #17

파일: OccupantActivities.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class OccupantActivitiesOccupantIdentity(IPrivacyAttack):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.OccupantActivities))
        # self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution, Literal("0", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Door))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))

        occupantActivitiesOccupantIdentity = self.MODELS[
            'OccupantActivitiesOccupantIdentity']
        self.graph.add((occupantActivitiesOccupantIdentity, self.RDF.type,
                        self.PRIVVULN.PrivacyAttack))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        occupantActivitiesOccupantIdentity))

        occupantIdentity = self.MODELS['OccupantIdentity']
        self.graph.add(
            (occupantIdentity, self.RDF.type, self.PRIVVULN.PrivacyRisk))
        self.graph.add((occupantIdentity, self.PRIVVULNV2.description,
                        Literal("This is bad!", datatype=self.XSD.string)))
        self.graph.add((occupantActivitiesOccupantIdentity,
                        self.PRIVVULN.creates, occupantIdentity))
        self.graph.add((occupantIdentity, self.PRIVVULNV2.privacyRiskScore,
                        Literal("4", datatype=self.XSD.int)))

예제 #18

파일: 10.1145-3408308.3427612.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

from rdflib import Graph, Namespace, URIRef, Literal
import rdflib
from Framework.driver import Driver
import Framework.namespace_util as NSUtil


g1 = Graph()

# source namespaces
RDF  = NSUtil.get_namespase_rdf()
RDFS = NSUtil.get_namespase_rdfs()
OWL  = NSUtil.get_namespase_owl()
XSD  = NSUtil.get_namespase_xsd()
PRIVVULN = NSUtil.get_namespase_base_ontology()
PRIVVULNV2 = NSUtil.get_namespase_extrantion_ontology()
SBUILDING = NSUtil.get_namespase_domain_smart_building()

g1.bind('rdf' , RDF)
g1.bind('rdfs', RDFS)
g1.bind('owl' , OWL)
g1.bind('xsd' , XSD)

# custom namespace
g1.bind('privvuln',PRIVVULN)

g1.bind('privvulnv2',PRIVVULNV2)

g1.bind('sbuilding',SBUILDING)

# model namespace
M = Namespace('https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')

예제 #19

class TemperatureSkinTemperatureToComfortLevel(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #doi: 10.1145/3360322.3360858
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("30", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.Temperature))

        spatialResolution1 = self.MODELS['SpatialResolution1']
        self.graph.add((spatialResolution1, self.RDF.type,
                        self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialInput,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((spatialResolution1, self.PRIVVULNV2.spatialOutput,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution1))

        spatialResolution2 = self.MODELS['SpatialResolution2']
        self.graph.add((spatialResolution2, self.RDF.type,
                        self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution2, self.PRIVVULNV2.spatialInput,
                        self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((spatialResolution2, self.PRIVVULNV2.spatialOutput,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode, self.PRIVVULN.feeds, spatialResolution2))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.SkinTemperature))

        inputNode3 = self.MODELS['inputRequirement3']
        self.graph.add((inputNode3, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode3, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode3, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ClothingInsulation))

        inputNode4 = self.MODELS['inputRequirement4']
        self.graph.add((inputNode4, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode4, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add(
            (inputNode4, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.Height))

        inputNode5 = self.MODELS['inputRequirement5']
        self.graph.add((inputNode5, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode5, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode5, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ShoulderCircumference))

        inputNode6 = self.MODELS['inputRequirement6']
        self.graph.add((inputNode6, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode6, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add(
            (inputNode6, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.Wight))

        inputNode7 = self.MODELS['inputRequirement7']
        self.graph.add((inputNode7, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode7, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add(
            (inputNode7, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.Gender))

        inputNode8 = self.MODELS['inputRequirement8']
        self.graph.add((inputNode8, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode8, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))
        self.graph.add((inputNode8, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Outside))
        self.graph.add((inputNode8, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.OutdoorTemperature))

        spatialResolution3 = self.MODELS['SpatialResolution3']
        self.graph.add((spatialResolution3, self.RDF.type,
                        self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution3, self.PRIVVULNV2.spatialInput,
                        self.__DOMAINNAMESPACE__.Outside))
        self.graph.add((spatialResolution3, self.PRIVVULNV2.spatialOutput,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode8, self.PRIVVULN.feeds, spatialResolution3))

        inputNode9 = self.MODELS['inputRequirement9']
        self.graph.add((inputNode9, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode9, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))
        self.graph.add((inputNode9, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Outside))
        self.graph.add((inputNode9, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.OutdoorHumidity))

        spatialResolution4 = self.MODELS['SpatialResolution4']
        self.graph.add((spatialResolution4, self.RDF.type,
                        self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution4, self.PRIVVULNV2.spatialInput,
                        self.__DOMAINNAMESPACE__.Outside))
        self.graph.add((spatialResolution4, self.PRIVVULNV2.spatialOutput,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode9, self.PRIVVULN.feeds, spatialResolution4))

        inputNode10 = self.MODELS['inputRequirement10']
        self.graph.add(
            (inputNode10, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode10, self.PRIVVULNV2.TemporalResolution,
                        Literal("300", datatype=self.XSD.double)))
        self.graph.add((inputNode10, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode10, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ThermalComfort))

        spatialResolution5 = self.MODELS['SpatialResolution5']
        self.graph.add((spatialResolution5, self.RDF.type,
                        self.PRIVVULNV2.SpatialResolution))
        self.graph.add((spatialResolution5, self.PRIVVULNV2.spatialInput,
                        self.__DOMAINNAMESPACE__.Outside))
        self.graph.add((spatialResolution5, self.PRIVVULNV2.spatialOutput,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode10, self.PRIVVULN.feeds, spatialResolution5))

        inputNode11 = self.MODELS['inputRequirement11']
        self.graph.add(
            (inputNode11, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode11, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))
        self.graph.add((inputNode11, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode11, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.HeartRate))

        inputNode12 = self.MODELS['inputRequirement12']
        self.graph.add(
            (inputNode12, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode12, self.PRIVVULNV2.TemporalResolution,
                        Literal("60", datatype=self.XSD.double)))
        self.graph.add((inputNode12, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Occupant))
        self.graph.add((inputNode12, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.GalvanicSkinResponseFeedback))

        temperatureSkinTemperatureToComfortLevel = self.MODELS[
            'TemperatureSkinTemperatureToComfortLevel']
        self.graph.add((temperatureSkinTemperatureToComfortLevel,
                        self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode3, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode4, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode5, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode6, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode7, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode8, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode9, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode10, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode11, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))
        self.graph.add((inputNode12, self.PRIVVULN['feeds'],
                        temperatureSkinTemperatureToComfortLevel))

        comfortLevel = self.MODELS['ComfortLevel']
        self.graph.add((comfortLevel, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((comfortLevel, self.RDF.type,
                        self.__DOMAINNAMESPACE__.ComfortLevel))
        self.graph.add((temperatureSkinTemperatureToComfortLevel,
                        self.PRIVVULN.feeds, comfortLevel))

예제 #20

class UltrasonicSpeakerUltrasonicMicToPresence(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #doi: 10.1145/2993422.2993580
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("120", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.UltrasonicSpeaker))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution,
                        Literal("120", datatype=self.XSD.double)))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.UltrasonicMicrophone))

        timeResolutionLinear2 = self.MODELS['timeResolutionLinear2']
        self.graph.add((timeResolutionLinear2, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear2, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear2, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add(
            (inputNode2, self.PRIVVULN.feeds, timeResolutionLinear2))

        ultrasonicSpeakerUltrasonicMicToPresence = self.MODELS[
            'UltrasonicSpeakerUltrasonicMicToPresence']
        self.graph.add((ultrasonicSpeakerUltrasonicMicToPresence,
                        self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'],
                        ultrasonicSpeakerUltrasonicMicToPresence))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'],
                        ultrasonicSpeakerUltrasonicMicToPresence))

        presence = self.MODELS['Presence']
        self.graph.add((presence, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add(
            (presence, self.RDF.type, self.__DOMAINNAMESPACE__.Presence))
        self.graph.add((ultrasonicSpeakerUltrasonicMicToPresence,
                        self.PRIVVULN.feeds, presence))

예제 #21

파일: MetabolicRate.py 프로젝트: EBC-Annex-79/Tool-chain_for_supporting_privacy_risk_assessments

class LimbMassAndLimbSurfaceAreaToMetabolicRate(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("1", datatype=self.XSD.double)))
        # self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Building))
        # self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Floor))
        # self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))
        # self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Zone))
        # self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.LimbMass))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution,
                        Literal("1", datatype=self.XSD.double)))
        # self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Building))
        # self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Floor))
        # self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Door))
        # self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Zone))
        # self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement, self.__DOMAINNAMESPACE__.Room))
        self.graph.add((inputNode2, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.LimbSurfaceArea))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        timeResolutionLinear2 = self.MODELS['timeResolutionLinear2']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add(
            (inputNode2, self.PRIVVULN.feeds, timeResolutionLinear1))

        limbMassAndLimbSurfaceAreaToMetabolicRate = self.MODELS[
            'LimbMassAndLimbSurfaceAreaToMetabolicRate']
        self.graph.add((limbMassAndLimbSurfaceAreaToMetabolicRate,
                        self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'],
                        limbMassAndLimbSurfaceAreaToMetabolicRate))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'],
                        limbMassAndLimbSurfaceAreaToMetabolicRate))

        metabolicRate = self.MODELS['MetabolicRate']
        self.graph.add(
            (metabolicRate, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((metabolicRate, self.RDF.type,
                        self.__DOMAINNAMESPACE__.MetabolicRate))
        self.graph.add((limbMassAndLimbSurfaceAreaToMetabolicRate,
                        self.PRIVVULN.feeds, metabolicRate))

예제 #22

def run_analyses(json):
    g1 = Graph()

    # source namespaces
    RDF = NSUtil.get_namespase_rdf()
    RDFS = NSUtil.get_namespase_rdfs()
    OWL = NSUtil.get_namespase_owl()
    XSD = NSUtil.get_namespase_xsd()
    PRIVVULN = NSUtil.get_namespase_base_ontology()
    PRIVVULNV2 = NSUtil.get_namespase_extrantion_ontology()
    SBUILDING = NSUtil.get_namespase_domain_smart_building()

    g1.bind('rdf', RDF)
    g1.bind('rdfs', RDFS)
    g1.bind('owl', OWL)
    g1.bind('xsd', XSD)

    # custom namespace
    g1.bind('privvuln', PRIVVULN)

    g1.bind('privvulnv2', PRIVVULNV2)

    g1.bind('sbuilding', SBUILDING)

    nodes = json["nodes"]

    links = json["links"]

    namespace = json["namespace"]
    M = Namespace(namespace)
    g1.bind('m', M)

    for node in nodes:
        if "name" not in node and "type" not in node:
            continue
        subject = M[node["name"]]
        g1.add((subject, RDF.type, rdflib.term.URIRef(node["type"])))
        if "superType" in node and node["superType"] != "" and node[
                "superType"] and node["superType"] != str(PRIVVULNV2.Context):
            g1.add((subject, RDF.type, rdflib.term.URIRef(node["superType"])))

        if "attributes" in node:
            for attribute in node["attributes"]:
                if "name" not in attribute and "value" not in attribute and "dataType" not in attribute:
                    continue

                if attribute["dataType"] == "int" or attribute[
                        "dataType"] == "double" or attribute[
                            "dataType"] == "string":
                    if attribute["value"] != '' and attribute["value"] != None:
                        g1.add(
                            (subject,
                             rdflib.term.URIRef(
                                 str(PRIVVULNV2) + attribute["name"]),
                             Literal(attribute["value"],
                                     datatype=rdflib.term.URIRef(
                                         str(XSD) + attribute["dataType"]))))

    for link in links:
        if "subject" not in link and "predicate" not in link and "object" not in link:
            continue
        g1.add((rdflib.term.URIRef(link["subject"]),
                rdflib.term.URIRef(link["predicate"]),
                rdflib.term.URIRef(link["object"])))

    driver = Driver(debug_mode=True)
    print("graph has %s statements." % len(g1))

    g1, risk_results, graph = driver.run_with_output(g1)

    print("graph has %s statements." % len(g1))

    returnJson = {
        'graph': str(graph.source),
        'privacy_report': risk_results,
    }

    return returnJson

예제 #23

class CamaraThermalCameraToSkinTemperate(ITransformation):
    __DOMAINNAMESPACE__ = NSUtil.get_namespase_domain_smart_building()

    def __init__(self):
        #DOI: 10.1145/3360322.3360848
        self.MODELS = Namespace(
            'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
        super().__init__(self.__DOMAINNAMESPACE__)

    def _build_model(self):
        inputNode = self.MODELS['inputRequirement1']
        self.graph.add((inputNode, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add((inputNode, self.PRIVVULN.feeds,
                        self.__DOMAINNAMESPACE__.ThermalCamera))
        self.graph.add((inputNode, self.PRIVVULNV2.TemporalResolution,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))

        timeResolutionLinear1 = self.MODELS['timeResolutionLinear1']
        self.graph.add((timeResolutionLinear1, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear1, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode, self.PRIVVULN.feeds, timeResolutionLinear1))

        inputNode2 = self.MODELS['inputRequirement2']
        self.graph.add((inputNode2, self.RDF.type, self.PRIVVULNV2.Constraint))
        self.graph.add(
            (inputNode2, self.PRIVVULN.feeds, self.__DOMAINNAMESPACE__.Camera))
        self.graph.add((inputNode2, self.PRIVVULNV2.TemporalResolution,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Building))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Zone))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Floor))
        self.graph.add((inputNode2, self.PRIVVULNV2.spatialRequirement,
                        self.__DOMAINNAMESPACE__.Room))

        timeResolutionLinear2 = self.MODELS['timeResolutionLinear2']
        self.graph.add((timeResolutionLinear2, self.RDF.type,
                        self.PRIVVULNV2.TimeResolutionLinear))
        self.graph.add((timeResolutionLinear2, self.PRIVVULNV2.TimeInput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add((timeResolutionLinear2, self.PRIVVULNV2.TimeOutput,
                        Literal("1", datatype=self.XSD.double)))
        self.graph.add(
            (inputNode2, self.PRIVVULN.feeds, timeResolutionLinear2))

        camaraThermalCameraToOccupantSkinTemperate = self.MODELS[
            'CamaraThermalCameraToOccupantSkinTemperate']
        self.graph.add((camaraThermalCameraToOccupantSkinTemperate,
                        self.RDF.type, self.PRIVVULN.Transformation))
        self.graph.add((inputNode, self.PRIVVULN['feeds'],
                        camaraThermalCameraToOccupantSkinTemperate))
        self.graph.add((inputNode2, self.PRIVVULN['feeds'],
                        camaraThermalCameraToOccupantSkinTemperate))

        occupantSkinTemperate = self.MODELS['OccupantSkinTemperate']
        self.graph.add(
            (occupantSkinTemperate, self.RDF.type, self.PRIVVULN.TimeSeries))
        self.graph.add((occupantSkinTemperate, self.RDF.type,
                        self.__DOMAINNAMESPACE__.SkinTemperature))
        self.graph.add((camaraThermalCameraToOccupantSkinTemperate,
                        self.PRIVVULN.feeds, occupantSkinTemperate))