Skip to content
GitLab
Commit 5bd22964 authored by Philipp Götze's avatar Philipp Götze
Browse files

Prepared Image and Graph Processing Use Cases, currently using the Test Cases

parent 8d285e08
Hide whitespace changes
Inline Side-by-side
documentation/UseCases.md
View file @ 5bd22964
......@@ -4,7 +4,7 @@ Here we want to describe and show some use cases for PipeFabric to give you an i
and necessary efforts of utilization. Therefore we provide the following topics:
+ DEBS2017, a research challenge for detecting anomalies in RDF streaming data
+ Image Processing, realized by matrix operations (coming soon)
+ Image and Graph Processing, realized by matrix operations
+ Processing of Movement Trajectories, tracking movement of different objects (coming soon)
To run them on your own, we give the necessary simple installation steps below because the use cases are not
......@@ -67,10 +67,9 @@ For data of real sensors with real manufacturing machines, this print could also
whatever the reaction to an anomaly should be.
### Image Processing ###
(coming soon!)
### Image and Graph Processing ###
Requires OpenCV and Eigen library to be installed (tested with opencv 3.3.1 and eigen 3.3.1)
### Movement Trajectories ###
......
src/CMakeLists.txt
View file @ 5bd22964
......@@ -26,7 +26,7 @@ option(SUPPORT_MATRICES
# Build use cases
option(BUILD_USE_CASES
""
OFF)
OFF)
# Use the boost::spirit parser for converting strings to numbers
option(USE_BOOST_SPIRIT_PARSER
......@@ -53,13 +53,13 @@ option(BUILD_ONLY_LIBS
# If switched to off, no tests will be build
option(BUILD_TEST_CASES
"build tests for pipefabric functionality"
ON
ON
)
#Build google benchmark library
option(BUILD_GOOGLE_BENCH
"build google benchmark"
ON
ON
)
# Build benchmark test
......@@ -74,7 +74,7 @@ option(BUILD_BENCHMARKS
# Use cases require matrix support (image and graph processing)
if(BUILD_USE_CASES)
set(SUPPORT_MATRICES)
set(SUPPORT_MATRICES ON)
endif()
# Benchmark test requires benchmark library
......
src/matrix/DenseMatrix.hpp
View file @ 5bd22964
......@@ -5,7 +5,7 @@
#include "BaseMatrix.hpp"
#include "ReaderValue.hpp"
#include <Eigen/Dense>
#include <eigen3/Eigen/Dense>
#include <boost/uuid/uuid.hpp>
......
src/matrix/SparseMatrix.hpp
View file @ 5bd22964
......@@ -6,7 +6,7 @@
#include "BaseMatrix.hpp"
#include "core/StreamElementTraits.hpp"
#include "ReaderValue.hpp"
#include <Eigen/Sparse>
#include <eigen3/Eigen/Sparse>
#include <mutex>
#include <boost/signals2.hpp>
......
src/usecases/CMakeLists.txt
View file @ 5bd22964
if (BUILD_USE_CASES)
add_subdirectory(DEBS2017)
endif()
add_subdirectory(DEBS2017)
add_subdirectory(MatrixProcessing)
\ No newline at end of file
src/usecases/MatrixProcessing/CMakeLists.txt 0 → 100755
View file @ 5bd22964
add_definitions(-DTEST_DATA_DIRECTORY="${CMAKE_CURRENT_SOURCE_DIR}/data/")
include_directories(${PROJECT_SOURCE_DIR}/test) #</ catch.hpp
add_executable(graph_test GraphTest.cpp)
target_link_libraries(graph_test
pfabric_core
${Boost_SYSTEM_LIBRARY}
)
add_executable(image_test ImageProcessingTest.cpp)
target_link_libraries(image_test
pfabric_core
${Boost_SYSTEM_LIBRARY}
${OpenCV_LIBS}
)
\ No newline at end of file
src/usecases/MatrixProcessing/GraphTest.cpp 0 → 100644
View file @ 5bd22964
#define CATCH_CONFIG_MAIN
#include <catch.hpp>
#include <vector>
#include "pfabric.hpp"
#include "operations/Graph.hpp"
#include "operations/GraphAlgorithms.hpp"
#include "matrix/Matrix.hpp"
#include "matrix/ReaderValue.hpp"
#include "qop/ToMatrix.hpp"
#include "StreamMockup.hpp"
using namespace pfabric;
typedef int CellType;
typedef TuplePtr<int, int, CellType> InputType;
typedef pfabric::Matrix<CellType, pfabric::ReaderValue<InputType> > MatrixType;
typedef pfabric::Graph< MatrixType > GraphType;
// adjacent matrix contains edges and values
std::vector< InputType > inputs = {
makeTuplePtr(0, 1, 1), makeTuplePtr(0, 2, 3),
makeTuplePtr(1, 0, 1), makeTuplePtr(1, 4, 1),
makeTuplePtr(2, 0, 3), makeTuplePtr(2, 3, 5), makeTuplePtr(2, 4, 4),
makeTuplePtr(3, 2, 5), makeTuplePtr(3, 4, 2),
makeTuplePtr(4, 1, 1), makeTuplePtr(4, 2, 4), makeTuplePtr(4, 3, 2)
};
std::shared_ptr<MatrixType> init_matrix(const std::vector<InputType> &inputs)
{
auto matrix = make_shared<MatrixType>();
auto mockup = std::make_shared<StreamMockup<InputType, InputType> >(inputs, inputs);
auto op = std::make_shared<ToMatrix<MatrixType>> (matrix);
CREATE_DATA_LINK(mockup, op);
mockup->start();
for(const auto& tuple : inputs ) {
auto x = tuple->getAttribute<0>();
auto y = tuple->getAttribute<1>();
auto z = tuple->getAttribute<2>();
matrix->set(x, y, z);
}
return matrix;
}
TEST_CASE("Observe graph values", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType graph(matrix.get());
REQUIRE(matrix->getRows() == 5);
REQUIRE(matrix->getCols() == 5);
REQUIRE(boost::num_vertices(graph) == 5);
auto weight_map = boost::get(boost::edge_weight, graph);
auto range_vertices_it = boost::vertices(graph);
for(auto vert_it = range_vertices_it.first; vert_it != range_vertices_it.second; ++vert_it) {
auto out_edges_pair = boost::out_edges(*vert_it, graph);
for(auto edge_it = out_edges_pair.first; edge_it != out_edges_pair.second; ++edge_it)
{
auto edge = *edge_it;
auto found_edge_it = std::find_if(inputs.begin(), inputs.end(), [&edge](const InputType& tuple) {
return edge.first == get<0>(tuple) && edge.second == get<1>(tuple);
});
if(found_edge_it != inputs.end()) {
REQUIRE(weight_map[edge] == get<2>(*found_edge_it));
} else {
REQUIRE(false);
}
}
}
}
TEST_CASE("Shortest path", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType graph(matrix.get());
auto node1 = 0;
{
auto node2 = 4;
REQUIRE(pfabric::shortest_path(graph, node1, node2) == 2);
}
{
auto node2 = 3;
REQUIRE(pfabric::shortest_path(graph, node1, node2) == 4);
}
}
TEST_CASE("Shortest path with context", "[GraphTest]")
{
StreamGenerator<InputType>::Generator stream([]( size_t n) -> InputType {
return inputs[n];
});
const std::string matrixName("exMatrix1");
PFabricContext ctx;
{
// A matrix is filling in one place
auto t = ctx.createTopology();
auto matrix = ctx.createMatrix<MatrixType>(matrixName);
auto s = t->streamFromGenerator<InputType>(stream, inputs.size())
.toMatrix<MatrixType>(matrix)
;
t->start(false);
}
// Shortest path is computed on another place by getting matrix from context
auto matrix = ctx.getMatrix<MatrixType>(matrixName);
GraphType graph(matrix.get());
auto node1 = 0;
{
auto node2 = 4;
REQUIRE(pfabric::shortest_path(graph, node1, node2) == 2);
}
{
auto node2 = 3;
REQUIRE(pfabric::shortest_path(graph, node1, node2) == 4);
}
}
TEST_CASE("Graph streaming", "[GraphTest]")
{
StreamGenerator<InputType>::Generator stream([]( size_t n) -> InputType {
return inputs[n];
});
const std::string matrixName("exMatrix");
PFabricContext ctx;
auto t = ctx.createTopology();
auto matrix = ctx.createMatrix<MatrixType>(matrixName);
auto s = t->streamFromGenerator<InputType>(stream, inputs.size())
.toMatrix<MatrixType>(matrix)
;
CellType shortest_path = std::numeric_limits<CellType>::max();
t->newStreamFromMatrix<MatrixType>(matrix)
.notify([&matrix, &shortest_path](const auto &tuple, bool outdated){
auto node1 = 0; auto node2 = 4;
GraphType graph(matrix.get());
auto res = pfabric::shortest_path(graph, node1, node2);
if(res < shortest_path) {
shortest_path = res;
std::cout << "\nshortest path: " << shortest_path;
}
})
;
t->start();
t->wait();
}
TEST_CASE("Sparse edge iterator", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto verify = [&g](std::size_t vertex, std::size_t id) {
auto range_it = boost::out_edges(vertex, g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto edge = *beg_it;
auto tuple = inputs[id++];
REQUIRE(edge.first == get<0>(tuple));
REQUIRE(edge.second == get<1>(tuple));
}
};
verify(0, 0);
verify(1, 2);
verify(2, 4);
verify(3, 7);
verify(4, 9);
}
TEST_CASE("Edges iterator", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto range_it = boost::edges(g);
auto id = 0u;
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto edge = *beg_it;
auto tuple = inputs[id++];
REQUIRE(edge.first == get<0>(tuple));
REQUIRE(edge.second == get<1>(tuple));
}
}
TEST_CASE("Vertices iterator", "[GraphTest]")
{
std::vector<typename GraphType::vertex_descriptor> expected = {0, 1, 2, 3, 4};
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto id = 0u;
auto range_it = boost::vertices(g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
REQUIRE(*beg_it == expected[id++]);
}
}
TEST_CASE("Count edges", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
REQUIRE(boost::num_edges(g) == inputs.size());
}
TEST_CASE("In edge test", "[GraphTest], [UndirectedGraph]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto verify = [&g](std::size_t vertex, std::size_t id)
{
auto range_it = boost::in_edges(vertex, g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto edge = *beg_it;
auto tuple = inputs[id];
REQUIRE(edge.first == get<1>(tuple));
REQUIRE(edge.second == get<0>(tuple));
}
};
verify(0, 0);
verify(1, 2);
verify(2, 4);
verify(3, 7);
verify(4, 9);
}
TEST_CASE("In degree", "[GraphTest], [UndirectedGraph]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
REQUIRE(boost::in_degree(0, g) == 2);
REQUIRE(boost::in_degree(1, g) == 2);
REQUIRE(boost::in_degree(2, g) == 3);
REQUIRE(boost::in_degree(3, g) == 2);
REQUIRE(boost::in_degree(4, g) == 3);
}
TEST_CASE("Vertex test", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
REQUIRE(boost::vertex(0, g) == 0);
REQUIRE(boost::vertex(1, g) == 1);
}
TEST_CASE("Edge test", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto range_it = boost::edges(g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto edge = *beg_it;
REQUIRE(boost::edge(edge.first, edge.second, g).second);
}
}
TEST_CASE("Adjacent test", "[GraphTest], [UndirectedGraph]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto verify = [&g](std::size_t vertex, std::size_t id) {
auto range_it = boost::adjacent_vertices(vertex, g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto tuple = inputs[id];
REQUIRE(*beg_it == get<0>(tuple));
}
};
verify(0, 0);
verify(1, 2);
verify(2, 4);
verify(3, 7);
verify(4, 9);
}
TEST_CASE("Edge test with nonexistent edges", "[GraphTest], [UndirectedGraph]")
{
std::vector<InputType> inputs = {makeTuplePtr(0, 1, 5), makeTuplePtr(0, 3, 2)
, makeTuplePtr(3, 2, 7)
};
std::vector<InputType> nonexistent = {makeTuplePtr(0, 2, 4), makeTuplePtr(1, 2, 7)};
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
{ // Precondition
auto range_it = boost::edges(g);
for(auto beg_it = range_it.first, end_it = range_it.second; beg_it != end_it; ++beg_it ) {
auto edge = *beg_it;
REQUIRE(boost::edge(edge.first, edge.second, g).second);
}
}
for(const auto &tuple : nonexistent) {
auto x = get<0>(tuple);
auto y = get<1>(tuple);
REQUIRE_FALSE(boost::edge(x, y, g).second);
}
}
TEST_CASE("Remove edge", "[GraphTest]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
REQUIRE(g.num_edges() == inputs.size());
auto numEdges = boost::in_degree(2, g);
REQUIRE(numEdges == 3);
auto range_it = boost::out_edges(2, g);
for(auto beg = range_it.first; beg != range_it.second; ++beg) {
auto edge = *beg;
g.remove_edge(edge.first, edge.second);
}
auto undirectedGr = 2;
REQUIRE(boost::num_edges(g) == inputs.size()-numEdges*undirectedGr);
}
TEST_CASE("Clear vertex", "[GraphTest] [UndirectedGraph]")
{
auto matrix = init_matrix(inputs);
GraphType g(matrix.get());
auto numEdges = boost::in_degree(2, g);
REQUIRE(numEdges == 3);
boost::clear_vertex(2, g);
auto undirectedGr = 2;
REQUIRE(boost::num_edges(g) == inputs.size()-numEdges*undirectedGr);
REQUIRE(boost::in_degree(2, g) == 0);
REQUIRE(boost::out_degree(2, g) == 0);
}
\ No newline at end of file
src/usecases/MatrixProcessing/ImageProcessingTest.cpp 0 → 100644
View file @ 5bd22964
#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
#include "catch.hpp"
#include "pfabric.hpp"
#include "matrix/DenseMatrix.hpp"
#include "operations/filters/GaussianFilter.hpp"
#include <fstream>
#include <sstream>
using namespace pfabric;
TEST_CASE("Gaussian blur image filter", "[ImageProcessing]")
{
typedef float CellType;
typedef VectorY<CellType> VectorCol;
typedef TuplePtr<int, int, VectorCol > InputType;
typedef TuplePtr<VectorCol> VectorTuple;
GaussianFilter filter(5, 3, CV_32FC3);
pfabric::Topology t;
std::ostringstream img_values;
t.newStreamFromFile(std::string(TEST_DATA_DIRECTORY)+"blur_image_test.in")
.extract<InputType>(',')
.map<VectorTuple>([](const auto& tp, bool) {
return makeTuplePtr(pfabric::get<2>(tp));
})
.map<VectorTuple>([&filter](const auto& tp, bool) {
auto &vector = get<0>(tp);
filter.apply(vector.getRawData(), vector.getRows(), vector.getCols());
return tp;
})
.print(img_values)
;
t.start(false);
std::ifstream f(std::string(TEST_DATA_DIRECTORY)+"blur_image_test.res");
std::stringstream expected;
if(f.is_open()) {
expected << f.rdbuf();
REQUIRE(img_values.str() == expected.str());
} else {
REQUIRE(false);
}
}
\ No newline at end of file
src/usecases/MatrixProcessing/data/blur_image_test.in 0 → 100644
View file @ 5bd22964
24,24,111 130 223 105 129 222 116 148 242 75 40 146 82 74 178 90 90 195 94 99 207 95 99 206 96 101 209 98 100 207 99 102 204 96 101 206 94 97 204 98 100 203 86 76 178 103 113 205 112 135 227 101 127 224 99 116 214 155 214 246 81 64 170 91 85 184 103 114 223 85 71 160 107 129 224 119 153 234 103 130 231 65 40 147 78 72 179 85 86 194 92 95 204 94 94 204 91 93 209 85 87 208 73 74 200 86 83 202 93 92 203 89 92 208 88 81 189 104 92 195 116 133 222 110 136 227 104 116 216 134 183 242 112 131 196 100 105 215 82 62 155 51 0 58 118 153 238 86 105 223 111 144 242 64 32 142 78 73 181 85 84 201 89 91 207 94 92 212 104 100 206 125 119 198 152 156 201 147 160 205 104 100 198 85 77 201 86 78 192 93 87 195 112 117 215 107 126 222 102 119 221 66 67 200 199 255 255 68 45 137 55 2 65 59 19 92 94 110 215 86 89 193 110 149 252 60 23 125 82 71 175 85 79 189 87 87 201 87 86 195 100 89 180 112 105 190 135 138 203 166 185 222 189 212 225 137 139 196 74 55 166 91 89 201 104 111 216 104 109 219 95 110 221 101 115 228 107 129 216 48 0 60 59 15 87 68 33 103 64 38 146 95 112 218 113 145 246 62 28 131 82 70 177 83 81 192 89 86 200 85 73 179 98 92 191 104 102 200 119 123 207 165 174 219 187 196 226 222 245 247 130 121 172 77 68 180 110 125 239 64 38 123 97 103 210 114 138 255 48 0 64 57 16 91 65 10 74 137 155 235 70 46 145 96 106 212 117 148 246 59 23 125 80 69 176 82 75 186 95 97 193 86 77 188 103 99 199 111 108 199 145 152 209 169 184 222 177 187 222 179 190 221 221 238 236 121 121 200 96 108 237 46 40 74 160 181 221 108 91 146 62 22 98 46 0 65 126 117 197 128 150 218 73 57 163 90 104 216 118 158 251 57 24 131 76 68 183 83 75 186 100 117 209 82 66 181 103 98 198 126 131 212 151 163 221 150 163 218 161 173 222 169 181 221 183 188 218 170 181 222 116 129 213 184 197 228 215 238 254 139 132 160 45 0 71 91 58 138 136 157 236 120 130 209 71 52 157 92 112 221 121 165 254 57 22 131 76 66 177 94 99 195 96 127 230 85 67 180 113 112 208 117 119 209 133 135 215 138 143 217 135 138 205 146 147 204 150 155 210 162 173 214 197 215 230 182 193 219 179 201 251 69 42 102 51 0 68 140 148 233 128 140 213 122 133 207 74 53 157 94 116 231 120 165 251 59 21 129 73 63 177 84 88 187 122 171 248 92 77 189 106 102 203 113 104 199 118 85 166 118 73 144 106 69 136 120 106 175 160 176 223 167 184 215 171 181 215 138 151 214 117 114 182 36 0 53 106 84 165 133 148 220 126 132 207 121 133 205 78 61 167 91 110 221 123 167 253 57 21 127 73 61 175 75 69 177 137 180 237 91 73 188 107 93 195 100 61 140 83 27 92 81 15 81 119 84 139 149 162 206 171 187 225 142 147 202 113 93 169 101 106 176 54 21 92 49 0 68 131 139 216 132 152 218 130 139 209 124 132 203 77 61 166 92 99 206 127 173 255 58 19 127 81 68 181 83 82 195 108 127 216 95 70 182 88 45 124 83 26 91 76 26 94 106 78 142 168 171 221 151 168 228 167 178 230 164 181 244 125 109 175 52 12 78 48 7 80 87 58 135 130 145 208 128 142 208 128 135 202 122 132 207 74 57 165 93 98 204 127 175 255 62 21 127 80 70 185 87 92 208 93 90 188 101 60 142 74 20 78 69 18 89 103 77 139 142 156 210 107 98 171 109 105 203 159 177 247 151 163 219 87 62 131 72 36 113 50 0 70 115 113 189 127 145 214 122 134 201 128 135 198 119 115 187 75 59 166 87 90 196 133 181 255 55 23 139 78 76 188 108 103 181 100 52 116 110 53 111 73 26 84 71 39 103 138 146 206 113 112 197 88 60 153 95 79 193 137 143 229 102 88 172 63 22 106 86 58 130 66 21 94 121 134 209 121 135 210 119 136 209 122 114 183 123 133 191 69 46 145 84 81 185 136 187 255 52 27 149 119 95 177 104 58 111 104 45 100 97 48 108 74 40 109 87 67 127 127 131 213 107 100 216 152 157 231 109 105 223 145 144 221 135 135 232 60 20 112 85 54 121 88 68 145 121 135 206 122 131 204 114 104 180 122 152 212 136 180 230 69 36 127 77 69 173 133 184 255 69 32 149 138 86 152 111 46 97 99 57 112 61 21 95 90 69 138 104 101 155 66 49 148 115 118 241 139 148 234 83 78 208 133 135 224 128 131 235 50 10 105 81 49 110 113 120 196 120 135 209 121 125 194 112 117 187 134 200 248 159 201 236 59 29 127 101 96 195 130 178 255 62 29 146 117 66 133 102 47 101 121 70 121 71 45 124 115 109 174 73 46 109 68 48 156 102 103 237 121 122 228 116 119 220 152 166 250 105 85 161 49 12 94 88 62 136 120 137 213 120 132 205 115 111 181 114 158 224 151 202 242 173 205 233 48 9 100 115 116 209 135 182 255 82 44 155 94 46 106 126 69 117 132 83 139 133 131 206 76 53 123 56 15 86 75 59 163 97 101 235 94 93 218 96 86 217 121 118 231 73 39 110 53 19 98 90 74 161 118 135 205 121 134 201 104 96 170 138 189 242 166 207 239 170 212 240 45 0 60 111 127 238 134 183 255 75 31 137 84 36 88 125 69 114 152 102 148 106 87 157 47 2 74 61 25 96 58 28 111 68 51 159 101 94 208 139 140 247 79 54 140 42 0 68 64 38 124 97 85 167 124 137 196 136 153 207 103 84 151 163 215 251 184 239 255 141 183 232 72 36 105 78 73 182 136 179 255 88 49 120 83 32 92 121 72 126 143 92 133 129 90 142 62 22 92 64 24 92 61 24 98 78 61 160 107 106 220 124 130 224 158 180 226 105 84 125 59 24 111 97 84 167 106 103 182 97 89 166 78 42 126 174 248 255 121 150 209 53 21 102 149 136 166 62 44 151 134 186 255 81 36 100 61 17 83 89 43 106 126 70 122 153 111 150 83 51 114 55 12 81 66 33 108 84 75 188 104 104 225 113 120 220 136 162 232 190 227 248 98 87 129 91 85 160 116 125 195 122 110 169 77 93 191 175 255 255 60 23 126 79 63 159 128 104 141 64 55 153 136 196 255 70 13 84 70 23 86 76 38 101 83 33 94 161 113 151 99 68 125 63 31 111 66 42 135 90 89 208 98 103 227 105 109 219 125 139 221 173 199 247 161 162 188 115 129 200 118 132 201 89 68 152 185 247 249 106 143 220 66 53 169 94 75 153 99 69 100 84 77 174 132 188 255 73 24 102 72 27 86 72 30 93 94 42 100 118 70 120 82 38 97 56 30 119 81 77 190 91 82 185 100 106 228 97 103 219 114 126 220 149 168 225 220 242 255 88 83 163 93 86 156 100 100 187 157 237 255 57 49 176 77 59 154 85 62 137 119 104 164 102 100 176 130 198 255 70 7 82 62 21 84 75 35 97 71 28 90 129 80 126 41 4 74 54 22 106 76 70 179 101 111 230 102 109 223 94 101 219 99 109 219 128 146 222 203 219 249 130 134 197 60 29 123 99 118 154 87 121 194 68 33 123 82 56 140 81 57 128 78 39 96 140 161 223 134 189 254 50 0 46 85 44 109 102 53 110 111 66 119 90 45 103 59 33 118 79 86 213 92 100 224 89 96 217 100 107 223 104 112 223 101 112 222 115 129 220 164 182 233 163 169 209 101 93 154 81 80 196 76 53 159 71 47 122 122 108 172 51 17 96
src/usecases/MatrixProcessing/data/blur_image_test.res 0 → 100644
View file @ 5bd22964
108.625 131.75 224.875 107.375 128.438 222.5 100.562 110.5 207.812 89.8125 84.1875 185.812 85.125 75.6875 180.062 88.375 85.6875 191.375 92.625 95.3125 202.062 94.875 99 206.375 96.3125 100.188 207.312 97.4375 100.75 206.625 97.5 100.875 205.562 96.5 100.125 204.875 95.3125 97.75 202.625 94.1875 94.125 197.312 95.375 96.25 195.688 100.562 109.312 204.812 104.562 122.625 216.875 106.75 130.812 222.438 113.188 141.188 222.562 115.125 138.5 213.75 104.5 113.125 198.562 95.125 94.1875 192.625 94.375 93.8125 194.25 97.5 102.25 197.875 104 119.625 210.875 106.5 129.062 220.688 96.1875 109.562 207.062 82.375 80.4375 184.375 78.9375 72.5625 179.562 84.3125 82.375 190.438 89.8125 90.9375 200.25 91.625 93.0625 204.875 89.1875 90.6875 206.625 84.125 85.4375 205.625 81.625 81.8125 203.25 84.625 83.8125 202.5 88.6875 87.9375 202.938 90.5 88.6875 200.812 94.3125 90.4375 198.188 102.438 102.25 203.062 109 119.188 214.062 111.125 130.438 221.938 114.25 139.75 224.375 117.375 145.438 221.375 112.125 132.25 210.938 97.5625 99.0625 187.125 82.875 67.25 153.5 80.75 66.875 147.375 90.5625 96.5 184.312 96.6875 115.625 216.125 91.375 102.375 208.188 81.9375 78.0625 185.5 79 71.0625 181.688 83.5 80.25 194.5 89.5 88.9375 205.062 96.625 94.9375 207.688 108.812 105.688 205.25 125.938 124.375 202.062 138 140.75 201.375 132.25 136.25 201.562 111.875 111.375 200.312 94.375 88.8125 197.875 90.25 83.8125 196.812 96.375 94.0625 201.312 103.75 109.438 210.688 103.562 115.875 216.938 100.938 116.125 217.75 110.938 129.312 216.438 117.938 131.188 197.75 96.8125 86.5 149.625 70.6875 39.5625 111 69 43.5 125.125 81.8125 77.6875 171.688 90.6875 100.75 202.688 88.75 95.1875 198.375 81.1875 74.125 177.5 79.3125 66.875 172.438 83.3125 75.9375 184.875 87 83.875 193.562 91.6875 87.75 192.062 101.125 95.1875 189 116.562 113.062 193.062 138.188 143.062 204.438 158.812 172.125 214.375 159.688 172.562 211.938 133.188 136 197.688 103.062 97.8125 189.062 93.6875 90.375 196.812 98.3125 101.438 210.188 100.75 108.875 218.188 100.062 112.25 221.625 97.875 109.688 212.188 87 84.9375 172.25 70.0625 45.25 118.938 61.8125 24.3125 96 65.1875 32.625 114.25 75.5 60.5 155.812 88 91.5625 194.375 90.75 96.125 199.688 83.125 76.3125 180.5 79.625 67.9375 175 83.0625 75.6875 185.625 86.625 80.875 190.75 90.3125 83.3125 189.375 97 91.3125 191.812 108.875 107.438 199.375 129.688 133.125 208.438 158.75 166.688 218.312 182.438 193.5 224.938 177.625 186.25 217.062 142.062 143.688 200.312 106.75 104.688 193.375 90.6875 87.375 189.25 87.6875 84.125 185.562 90.75 90.4375 192.188 86.5625 80.875 177.5 70.875 45.5625 128.25 65.3125 26.8125 99.25 80.25 49.375 122.312 94.6875 79.75 161.812 95.875 92.375 186.125 95 99.375 199.75 92 94.9375 196.562 82.5 74.1875 177.25 78.5 65.6875 171.188 83.5625 75.875 181.562 89.0625 84.875 189.312 93.8125 89.3125 192.562 102.875 98.9375 196.5 119.562 119.562 202.25 141.875 147.875 209.938 162 172.375 217.25 176.25 188 221.812 184.75 196.562 223.75 174.938 185.438 222.438 138.688 146.25 211.688 101.562 106.938 185.938 95.5625 100.5 163.875 108.375 108.75 158.812 101.75 87.375 143.188 79.625 49.625 115.625 79 49.8125 120.875 99.1875 86.3125 160.938 106.25 106.25 189.312 97.125 102.062 197.625 93.0625 103.625 206.312 90.3125 99.0625 202.5 80.6875 76.6875 182.75 77.125 67.4375 176.625 83.8125 80 187.25 89.9375 89.5 193.938 94.5625 91.375 194.5 106.312 103.5 199.375 125.25 128.688 209.188 142.125 151.562 216.625 152.688 164.625 219.562 161 172.812 220.438 169.375 179.625 220.375 170.688 179.875 219.688 160.562 170.75 219.062 156.875 169.5 221.875 171.062 185.188 226.125 171.438 179.562 210 134.312 124.938 164.125 96.3125 72.1875 131.75 95.5625 77.375 151.562 111 109.125 189.5 108.188 111.625 199.062 95.6875 100.125 197 93.5625 105.75 206.875 91.8125 102.75 204.125 82.25 79.1875 182.875 79.8125 73.25 178.125 87.125 90.9375 194.312 92.5625 100.25 204.062 97.3125 98.5 202.25 107.188 104.875 203.062 119.312 119.5 208.938 129.125 131.75 212.938 135.188 138.5 212.188 139.312 142.375 208.688 144.75 148.125 207.188 154 160.188 210.438 168 178.625 216.688 180.438 194.375 223.312 176.688 189.812 222.125 145.375 147.562 193 103.5 87.3125 146.25 90.5625 68.8125 138.25 109.188 101.438 176.938 121.312 126.062 203.938 110.875 114.625 199.125 97.25 101.188 197.375 95.0625 107.625 209.625 92.4375 103.375 205 81.5 77.625 181.5 78.25 71.875 176.562 89.6875 97.625 196.25 100.938 115.688 210.75 103.812 109.125 207.75 106 99.5 199 111.5 95.125 187.688 115.25 86.8125 169.188 114.812 79 152.875 116.625 86.9375 155.062 129.312 117.062 177.812 149.062 154.125 203.062 161.5 174.312 214.438 157.688 169.75 213.188 136.438 141.875 196.25 104.688 97.0625 158.75 86.1875 68.1875 133.75 97.1875 83.875 154.438 117.688 117.812 191.625 122.25 128.812 204.625 110.375 114.25 197.938 97.8125 102.312 197.875 95.5 107.875 208.625 92.5625 103 203.25 80.75 76.0625 179.5 76.625 67.0625 172.25 89.875 92 189.062 104.125 112.625 203.25 106.062 103.75 198.312 101.625 81.3125 175.688 95.75 58.375 141.062 90.5 40.1875 110.625 96.4375 47.3125 109.75 118 89.125 143.688 142.312 138.625 185.938 151.375 158.438 205.625 139.875 141.875 198.125 117.188 111.125 177.688 91.5625 77.4375 148.125 73 48.875 119.562 79.1875 56.125 127.125 105.875 100.125 171.312 125.562 134.75 204.938 125.75 135.625 207.5 112.25 115.188 196.375 98.9375 100.125 193.5 96.875 105.062 203.125 95 102.438 200.562 84.6875 78.6875 181.688 80.3125 69.5 177.812 87.9375 85.0625 191.688 95.5625 92.6875 194.312 95 76 171.125 89 50.4375 134.125 84.6875 36.75 108.875 91.75 49.25 115.062 115.375 90.625 151.938 142.438 138.375 195.625 157.25 166.438 222.375 159.688 171.5 229 147.188 150.875 211.875 114.312 100.688 165.5 78.4375 48.4375 116.688 68.6875 36 107.188 88.375 69.375 140.5 113.5 113.25 181.375 125.562 135.125 201.875 123.25 131.75 202.812 110.062 112.5 195.125 97.4375 98.25 193.188 96.625 104.312 202.375 96 103.312 200.25 86.25 81 183.375 81 71.0625 180.812 86.0625 79.5625 188.062 91.5 77.375 174.438 89.375 56.875 138.312 82.5 37.4375 107.438 85.3125 44.5 109.625 102.688 79.75 142.438 116.875 109.938 174.5 119.25 117.875 191.5 125.688 128.062 207.438 136.75 143.375 217 129.438 129.688 196.375 101.438 84.0625 151.938 77.875 46.25 118.125 78.875 50.1875 123.312 99.5 89.25 161.5 118 124.562 194.5 124.125 134.5 201.875 120.875 125.625 195 108.438 105.625 185.938 95.9375 93.125 186.312 95.5 102.375 199.125 94.9375 104.562 201.5 85.5625 84.9375 186.438 84.5625 74.5625 173.688 95.3125 75.375 159.5 101.438 64.875 133.5 95.6875 48.25 109.375 87.5 45.125 105.125 93.3125 67.9375 130.375 107.812 97.875 167.062 109.25 100.875 182.125 102.188 88.3125 182.062 105.312 92.875 190.938 110.062 100.5 193.312 99.5625 82.8125 168.438 83.3125 55 135.438 78.4375 46.375 122.562 88 65.6875 139.75 104.938 101.375 175.562 117.125 126.562 200.562 120.625 129.938 201.625 118.125 121.312 190.812 106.562 103.438 178.25 93.75 89.5625 175.75 93.6875 98.625 190.625 96.75 105.938 199.25 95 89.3125 182.375 98.625 71.375 153.562 104.062 61.4375 126.938 101.312 51.8125 110.125 92.8125 47.0625 107.625 88.1875 54.75 119.188 95.625 77.125 148.375 110.25 103.188 186.875 122.125 120.25 213.875 128 127.312 223.5 130.25 129.312 224.625 128.625 125.062 218.062 114 101.562 191.75 92.0625 68 153.125 84.875 59.125 137 95.875 82.1875 155.875 110.312 110.25 183.312 117.625 122.625 195.312 119.812 129.438 198.75 120.188 138.438 202.688 110.688 125.312 193.062 95.0625 96.75 177.562 92.1875 94.125 184.062 99.3125 101.875 193.562 105.375 86.6875 174.5 111.25 66.8125 141.438 109 56.3125 117.625 94.375 47.8125 108.125 83.5625 48.5625 113.875 85.3125 63 130.5 89 76.0625 150.625 93.8125 86.6875 177.75 106.062 104.688 208.562 114.062 116 223.25 114.312 115.562 222.25 114.438 112.75 215.938 104 93.3125 190.25 86.375 64.6875 151.875 86.625 67.5 144.25 103.312 99.4375 171.938 115.562 122.25 194.438 118.812 129.875 199.5 123.188 146.125 208.438 129.25 164.125 218.812 121.188 145.938 206.125 103.625 108.75 186.812 98.9375 102.125 192.5 100.5 103.938 197.125 97.6875 80.8125 170.25 100.562 59.25 135.125 106.062 56.25 118.25 103.125 60.1875 120.812 96.5625 67.4375 133.375 90.9375 71 140.812 83.9375 65.75 145.938 84 69.6875 170.125 97.3125 91.4375 205.438 113.625 114.625 225.125 124.688 128.375 226.875 122.875 121.625 209.125 102.375 87.6875 168.625 83.625 60.1875 138.438 89.3125 74.0625 150.625 107.25 107.562 182.312 116.375 125.25 197.875 118.562 135.312 203.562 127.562 158.562 217.125 138.562 174 222.562 128.938 146.75 199.938 107.875 107.625 179.062 104.812 106.812 191.375 108.75 111.688 199.5 103.062 85.0625 168.75 103.938 62.0625 132.375 117.188 69.0625 127.688 124.875 87.3125 147.188 113.25 88.375 155.438 88.6875 65.25 138 73.125 48.125 131.312 77 60.25 162.688 88.125 82.1875 202.312 95.75 92.6875 219.375 100.375 93.75 215.188 96.8125 82.5 188.125 82.5 58.875 147.125 75.5625 51.1875 131.75 88.625 77.0625 155.562 106.812 109.812 184.125 115.125 124.438 194.312 121.5 138.125 202.25 137.438 168.25 220.562 148.562 183.875 224.5 132.062 151 194.75 105.875 109.125 172.875 101.688 108.562 191.562 104.812 110.375 198.625 97.375 78.625 159.125 99.375 56.3125 120.938 117.188 67.75 120.125 122.938 79.625 133.375 101.125 64.5 127.5 72.5 36.875 107.188 60 25.5 102 63.25 35.5 123 77.75 59.9375 160.812 98.1875 88.125 195.188 104 92.6875 193.812 85.1875 63.5 152 66.25 37.0625 117.375 71.4375 47.4375 126.25 94.5 85.1875 159.812 115.188 118.5 184.188 124 131.375 190.5 132.625 147 199.312 150.188 182.375 223.062 155.938 196.625 232.375 131.938 155.375 204.062 101.75 103.625 174.75 95.5625 95.625 180.25 102.188 101.875 183.438 100.188 80.1875 151 100.812 59.1875 120.25 115.438 66.6875 119.875 125.188 78.375 128.375 111.188 68.25 123.125 84.25 44 107.438 67.6875 29.9375 100.875 68.9375 38.25 119.25 83 65 159.25 104.312 100.25 198.75 124.188 129.312 213.312 126.875 129.125 192.688 107.438 95.875 155.562 89.125 68.6875 140.125 90.25 74.0625 154.062 96.8125 86 166.312 99.3125 90.375 165.625 111.188 115.812 176.938 124.375 147.875 196.125 116.312 134.625 185.875 102.125 97.625 157.375 100.562 88.25 154.5 102.375 100.562 174.5 99.125 99.3125 173.938 88.5625 69.6875 138.062 81.625 42.125 106.188 94.75 47.0625 106.625 116.75 69 122.062 118.625 75.3125 126.938 95.125 56.3125 114.875 72.6875 37.125 107 71.1875 43.8125 128.938 84.5 70.625 172.562 100.875 99.9375 207.625 119.5 130.375 224 139.375 159.438 226.125 142.5 160.188 207 122.75 128.562 177.062 107.125 105.938 167.062 107.688 106.875 175.375 110.625 117 185.812 114.125 135.375 197.688 112.438 135.438 195.375 98.8125 100.438 171.5 91.5625 74.75 151.875 96 82.1875 154.688 99.3125 100.375 171.562 96.875 98.4375 169.062 86.5 65.4375 132.625 76.4375 35.6875 100.312 81.1875 36.125 97.5625 100.938 55.8125 111.438 114.562 71.9375 124.625 102.438 66.1875 126.688 80.5625 51.75 129.062 75.3125 56.4375 152.375 85.25 78.375 189.125 97.4375 99.4375 214.125 111.562 119.375 222.562 132.562 145.688 225.312 150.125 164.75 221.062 147.562 159.688 208.625 129.25 138.562 197.188 116.875 124.312 190.688 122.938 137.25 195.75 129.625 156.938 209.5 113.938 137.562 206.062 92.5 94.125 178.438 88.375 72.375 149.25 94 78.9375 145.75 99.6875 99.3125 169.938 99.4375 101.75 176.25 88.125 69.4375 140.188 77.375 38 103.188 80.4375 34.375 95.25 92.375 44.8125 102.188 96.25 50 107.5 85.1875 46.6875 114.25 74.8125 49.5 135.438 78.5 65.875 167.562 88.9375 84.8125 195 96.6875 98.6875 212.125 104.875 112.25 219.75 124.25 136.75 223.688 150.938 166.625 227 154.688 166.75 216.125 126.812 129.875 189.625 105.438 107.938 177.875 109.062 126.5 194.062 108.75 135.188 205.75 91.4375 102.5 188.5 81.625 71.1875 162.188 90.8125 73.3125 152.875 104.312 95.5625 165.312 110.188 117.312 184.438 103.062 108.812 175.625 85.3125 65.8125 132.562 72.0625 32.5 97.8125 73.8125 30.8125 92.875 84.0625 40.8125 99.375 84.4375 41.5625 100.938 70.3125 33.125 102.562 63.875 38.6875 125.25 76.1875 66.5625 169.688 91.625 94.0625 207.062 97.9375 105.062 220.75 99.8125 108.438 220.875 111.688 123.125 221.875 137.5 151.438 226.25 150.562 160.75 219.5 128.688 128.75 190.375 97.875 95.125 161.562 86.25 92.1875 157 83.25 88.4375 158.438 79 67.5625 147.25 78.3125 53.5 133.375 83.375 57.25 128.625 98 84.4375 148.375 113.688 120.938 182 107.938 116.312 175.312 88.625 71.625 128.812 85.1875 45.6875 103.188 96 50.1875 107.562 98.625 54.0625 112.062 87.5625 50.3125 118.062 77.0625 55.5 144.688 78.5625 74.3125 185.375 86.4375 91.75 212.812 92.8125 100.125 220.375 97.8125 105.375 221.5 102 110.812 222.188 109.125 120.312 222.5 126.062 139.438 223.25 143.625 155.562 218.125 139.625 145.188 201.125 113.875 111.812 183.5 89.25 80 172.438 80.4375 64.1875 159.5 84.375 63.9375 146.75 88.625 66.5625 139.688 89 66.25 137.25
src/usecases/MatrixProcessing/operations/Graph.hpp 0 → 100644
View file @ 5bd22964
#ifndef Graph__HH
#define Graph__HH
#include "matrix/BaseMatrix.hpp"
#include <boost/graph/graph_traits.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/graph/properties.hpp>
// Forward declaration
namespace pfabric {
template<typename M>
class Graph;
}
// traits for our Graph class