cecile-supercool-tracker 0.0.1

Machine learning framework for building object trackers and similarity search engines
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::store::TrackStore;
use crate::track::notify::{ChangeNotifier, NoopNotifier};
use crate::track::{ObservationAttributes, ObservationMetric, TrackAttributes};
use std::marker::PhantomData;

/// Builder for TrackStore
///
pub struct TrackStoreBuilder<TA, M, OA, N = NoopNotifier>
where
    TA: TrackAttributes<TA, OA>,
    M: ObservationMetric<TA, OA>,
    OA: ObservationAttributes,
    N: ChangeNotifier,
{
    metric: Option<M>,
    default_attributes: Option<TA>,
    notifier: Option<N>,
    shards: usize,
    _phantom_oa: PhantomData<OA>,
}

/// Default builder
/// shards count is set to number cpu cores (threads)
///
impl<TA, M, OA, N> Default for TrackStoreBuilder<TA, M, OA, N>
where
    TA: TrackAttributes<TA, OA>,
    M: ObservationMetric<TA, OA>,
    OA: ObservationAttributes,
    N: ChangeNotifier,
{
    fn default() -> TrackStoreBuilder<TA, M, OA, N> {
        Self::new(num_cpus::get())
    }
}

impl<TA, M, OA, N> TrackStoreBuilder<TA, M, OA, N>
where
    TA: TrackAttributes<TA, OA>,
    M: ObservationMetric<TA, OA>,
    OA: ObservationAttributes,
    N: ChangeNotifier,
{
    /// Creates a new builder
    ///
    /// # Parameters
    /// * `shards` - number of shards to use (the parameter by default is equal to cores count), should be chosen experimentally, depending on tracker kind.
    ///
    pub fn new(shards: usize) -> Self {
        TrackStoreBuilder {
            shards,
            metric: None,
            default_attributes: None,
            notifier: None,
            _phantom_oa: PhantomData,
        }
    }

    /// Sets the metric object to use
    ///
    pub fn metric(mut self, metric: M) -> Self {
        assert!(
            self.metric.is_none(),
            "The method `metric` must be called once."
        );
        self.metric = Some(metric);
        self
    }

    /// Sets the notifier object to use
    ///
    pub fn notifier(mut self, notifier: N) -> Self {
        assert!(
            self.notifier.is_none(),
            "The method `notifier` must be called once."
        );
        self.notifier = Some(notifier);
        self
    }

    /// Sets the default track attributes to use for new tracks
    ///
    pub fn default_attributes(mut self, attrs: TA) -> Self {
        assert!(
            self.default_attributes.is_none(),
            "The method `default_attributes` must be called once."
        );
        self.default_attributes = Some(attrs);
        self
    }

    /// Builds the TrackStore
    ///
    pub fn build(self) -> TrackStore<TA, M, OA, N> {
        TrackStore::new(
            self.metric.unwrap(),
            self.default_attributes.unwrap(),
            self.notifier.unwrap(),
            self.shards,
        )
    }
}