File size: 4,099 Bytes
a6dd040 |
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 103 104 105 106 107 108 109 |
/*
* Copyright (c) 2020 NVIDIA Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*
* Please cite "4D Spatio-Temporal ConvNets: Minkowski Convolutional Neural
* Networks", CVPR'19 (https://arxiv.org/abs/1904.08755) if you use any part
* of the code.
*/
#ifndef KERNEL_MAP_HPP
#define KERNEL_MAP_HPP
#include "types.hpp"
#include <ostream>
#include <tuple>
#include <vector>
namespace minkowski {
/*
* Kernel map specific types
*/
using cpu_in_map = default_types::index_vector_type;
using cpu_out_map = default_types::index_vector_type;
// Input index to output index mapping for each spatial kernel
using cpu_in_maps = std::vector<cpu_in_map>;
using cpu_out_maps = std::vector<cpu_out_map>;
struct cpu_kernel_map : std::pair<cpu_in_maps, cpu_out_maps> {
using index_type = default_types::index_type;
using index_pair =
std::pair<default_types::index_type, default_types::index_type>;
cpu_kernel_map() : std::pair<cpu_in_maps, cpu_out_maps>() {}
cpu_kernel_map(std::pair<cpu_in_maps, cpu_out_maps> const &other)
: std::pair<cpu_in_maps, cpu_out_maps>(other) {}
// origin map initialization.
cpu_kernel_map(std::vector<index_pair> &in_out,
std::vector<default_types::dcoordinate_type> const
&unique_batch_indicies) {
auto comp = [](std::pair<index_type, index_type> const &l,
std::pair<index_type, index_type> const &r) {
return l.second < r.second;
};
std::sort(in_out.begin(), in_out.end(), comp);
auto const kernel_volume = unique_batch_indicies.size();
this->first.resize(kernel_volume);
this->second.resize(kernel_volume);
for (index_type k = 0; k < unique_batch_indicies.size(); ++k) {
auto const lb = std::lower_bound(in_out.begin(), in_out.end(),
index_pair{0, k}, comp);
auto const ub = std::upper_bound(in_out.begin(), in_out.end(),
index_pair{0, k}, comp);
auto const curr_size = ub - lb;
default_types::index_type start_index = lb - in_out.begin();
LOG_DEBUG("batch row_index:", k, "curr_size:", curr_size,
"start_index:", start_index);
// resize
auto &in_map = this->first[k];
auto &out_map = this->second[k];
in_map.resize(curr_size);
out_map.resize(curr_size);
// copy
for (uint32_t i = 0; i < curr_size; ++i) {
auto const &curr_pair = in_out[i + start_index];
in_map[i] = curr_pair.first;
out_map[i] = curr_pair.second;
}
}
}
friend std::ostream &operator<<(std::ostream &out,
cpu_kernel_map const &kernel_map) {
uint32_t map_size = 0;
for (auto const &v : kernel_map.first) {
map_size += v.size();
}
out << "cpu_kernel_map: number of unique maps:" << kernel_map.first.size()
<< ", kernel map size:" << map_size;
return out;
}
};
using cpu_kernel_map_reference = std::pair<cpu_in_maps &, cpu_out_maps &>;
} // namespace minkowski
#endif
|