diff --git a/alib2measurepp/src/processor/MeasurementProcessor.cpp b/alib2measurepp/src/processor/MeasurementProcessor.cpp
index a4a9cf3cc902d96271b4d6d03823c06348e6ff6a..1ee1ddee166b00c213a86626ff554125d1eac1bf 100644
--- a/alib2measurepp/src/processor/MeasurementProcessor.cpp
+++ b/alib2measurepp/src/processor/MeasurementProcessor.cpp
@@ -3,13 +3,82 @@
  */
 
 #include "MeasurementProcessor.hpp"
+#include <iostream>
 
 namespace measurements {
 
-MeasurementProvisionerResults MeasurementProcessor::process ( MeasurementProvisionerResults mpr, const MeasurementProcessorFilter &  ) {
-	MeasurementProvisionerResults newmpr = std::move ( mpr );
+MeasurementProvisionerResults MeasurementProcessor::process ( MeasurementProvisionerResults mpr, const MeasurementProcessorFilter & filter ) {
+	MeasurementProvisionerResults newmpr;
+
+	for ( MPRResults & mprr : mpr.results ) {
+		MPRResults newmprr;
+		newmprr.inputs = std::move ( mprr.inputs );
+
+		for ( MPRPipelineResults & mprpr : mprr.pipelineResults ) {
+			MPRPipelineResults newmprpr;
+			newmprpr.pipelineStatus = std::move ( mprpr.pipelineStatus );
+
+			for ( MPRPipelineCommandResults & mprpcr : mprpr.commandResults ) {
+
+				 // filter out commands
+				if ( !filter.matches ( MeasurementProcessorFilter::FilterType::COMMAND, mprpcr.command ) ) continue;
+
+				MPRPipelineCommandResults newmprpcr;
+				newmprpcr.command = std::move ( mprpcr.command );
+
+				newmprpcr.measurementResults = processMeasurementResults ( mprpcr.measurementResults, filter );
+
+				newmprpr.commandResults.push_back ( std::move ( newmprpcr ) );
+			}
+
+			if ( newmprpr.commandResults.size ( ) )
+				newmprr.pipelineResults.push_back ( std::move ( newmprpr ) );
+		}
+
+		if ( newmprr.pipelineResults.size ( ) )
+			newmpr.results.push_back ( std::move ( newmprr ) );
+	}
 
 	return newmpr;
 }
 
+MeasurementResults MeasurementProcessor::processMeasurementResults ( const MeasurementResults & mr, const MeasurementProcessorFilter & filter ) {
+	MeasurementResults newmr;
+
+	std::function < void ( unsigned, unsigned ) > dfsLambda;
+
+	dfsLambda = [&] ( unsigned idx, unsigned newmrParentIdx ) {
+					if ( idx == 0 ) {
+						newmr.frames.push_back ( mr.frames[0] );
+						newmr.frames[0].sub_idxs.clear ( );
+
+						for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+							dfsLambda ( subIdx, 0 );
+					} else {
+						const MeasurementFrame & curFrame = mr.frames[idx];
+
+						bool filteredOut = false;
+						filteredOut |= !filter.matches ( MeasurementProcessorFilter::FilterType::FRAME_TYPE, to_string ( curFrame.type ) );
+						filteredOut |= !filter.matches ( MeasurementProcessorFilter::FilterType::FRAME_NAME, to_string ( curFrame.name ) );
+
+						if ( !filteredOut ) {
+							unsigned newmrIdx = newmr.frames.size ( );
+							newmr.frames.push_back ( mr.frames[idx] );
+							newmr.frames[newmrIdx].sub_idxs.clear ( );
+							newmr.frames[newmrParentIdx].sub_idxs.push_back ( newmrIdx );
+
+							for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+								dfsLambda ( subIdx, newmrIdx );
+						} else {
+							for ( unsigned subIdx : mr.frames[idx].sub_idxs )
+								dfsLambda ( subIdx, newmrParentIdx );
+						}
+					}
+				};
+
+	dfsLambda ( 0, 0 );
+
+	return newmr;
+}
+
 }
diff --git a/alib2measurepp/src/processor/MeasurementProcessor.hpp b/alib2measurepp/src/processor/MeasurementProcessor.hpp
index b3e5511fefaf9ad4b2c09ee814e0e591c9d88c23..9684f2463f93a849fb71e5c402c48cefb11108b5 100644
--- a/alib2measurepp/src/processor/MeasurementProcessor.hpp
+++ b/alib2measurepp/src/processor/MeasurementProcessor.hpp
@@ -12,8 +12,11 @@ namespace measurements {
 
 class MeasurementProcessor {
 
+	static MeasurementResults processMeasurementResults ( const MeasurementResults &, const MeasurementProcessorFilter & );
+
+
 public:
-	static MeasurementProvisionerResults process(MeasurementProvisionerResults, const MeasurementProcessorFilter &);
+	static MeasurementProvisionerResults process ( MeasurementProvisionerResults, const MeasurementProcessorFilter & );
 };
 
 }
diff --git a/alib2measurepp/src/processor/MeasurementProcessorFilter.cpp b/alib2measurepp/src/processor/MeasurementProcessorFilter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c4fba9c8ba104748d782312367602d2c757b765
--- /dev/null
+++ b/alib2measurepp/src/processor/MeasurementProcessorFilter.cpp
@@ -0,0 +1,29 @@
+/*
+ * Author: Radovan Cerveny
+ */
+
+#include "MeasurementProcessorFilter.hpp"
+
+namespace measurements {
+
+void MeasurementProcessorFilter::add ( FilterType type, const std::string & str ) {
+	filters[type].insert ( str );
+}
+
+void MeasurementProcessorFilter::remove ( FilterType type, const std::string & str ) {
+	filters[type].erase ( str );
+
+	if ( filters[type].empty ( ) ) filters.erase ( type );
+}
+
+bool MeasurementProcessorFilter::matches ( FilterType type, const std::string & str ) const {
+	auto filtersIter = filters.find ( type );
+
+	if ( filtersIter == filters.end ( ) ) return true;
+
+	const auto & filterSet = filtersIter->second;
+
+	return filterSet.find ( str ) != filterSet.end ( );
+}
+
+}
diff --git a/alib2measurepp/src/processor/MeasurementProcessorFilter.hpp b/alib2measurepp/src/processor/MeasurementProcessorFilter.hpp
index 12beebd9cb5b1215a71d3bbfe0a5de1e4fe3b7f9..d7b671b294672eed3cfafa5dfefd6877f395efa8 100644
--- a/alib2measurepp/src/processor/MeasurementProcessorFilter.hpp
+++ b/alib2measurepp/src/processor/MeasurementProcessorFilter.hpp
@@ -6,15 +6,25 @@
 #define MEASUREMENT_PROCESSOR_FILTER_HPP_
 
 #include <map>
-#include <vector>
+#include <set>
 
 namespace measurements {
 
-enum class MeasurementProcessorFilterType {
-	FRAME_TYPE,	FRAME_NAME,	COMMAND
+class MeasurementProcessorFilter {
+public:
+	enum class FilterType {
+		FRAME_TYPE,	FRAME_NAME,	COMMAND
+	};
+
+private:
+	std::map < FilterType, std::set < std::string > > filters;
+
+public:
+	void add ( FilterType, const std::string & );
+	void remove ( FilterType, const std::string & );
+	bool matches ( FilterType, const std::string & ) const;
 };
 
-using MeasurementProcessorFilter = std::map < MeasurementProcessorFilterType, std::vector < std::string > >;
 }
 
 #endif /* MEASUREMENT_PROCESSOR_FILTER_HPP_ */
diff --git a/alib2measurepp/src/provisioner/MeasurementProvisionerResults.hpp b/alib2measurepp/src/provisioner/MeasurementProvisionerResults.hpp
index 50590fe5b7b8aaa2c00f774fe458a5c7e447cbfd..d92afd8b56e40f50a5b5962e8395cd83ae10c025 100644
--- a/alib2measurepp/src/provisioner/MeasurementProvisionerResults.hpp
+++ b/alib2measurepp/src/provisioner/MeasurementProvisionerResults.hpp
@@ -12,7 +12,7 @@ namespace measurements {
 
 struct MPRPipelineCommandResults {
 	std::string						 command;
-	measurements::MeasurementResults measurementResults;
+	MeasurementResults measurementResults;
 };
 
 struct MPRPipelineStatus {
diff --git a/ameasurep2/src/ameasureproc.cpp b/ameasurep2/src/ameasureproc.cpp
index bdc669ba75826ce2a07508ec6200defcb467491e..5dec69b7be41176e3280ada793ec78efe8d51ad7 100644
--- a/ameasurep2/src/ameasureproc.cpp
+++ b/ameasurep2/src/ameasureproc.cpp
@@ -15,6 +15,7 @@ int main ( int argc, char * * argv ) {
 		TCLAP::CmdLine cmd ( "Measurement processor binary", ' ', "0.01" );
 
 		std::vector < std::string > allowedOutput;
+		allowedOutput.push_back ( "xml" );
 		allowedOutput.push_back ( "stats" );
 		allowedOutput.push_back ( "csv" );
 		allowedOutput.push_back ( "html" );
@@ -59,13 +60,13 @@ int main ( int argc, char * * argv ) {
 		measurements::MeasurementProcessorFilter filter;
 
 		for ( const std::string & f : filterByFrameType.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::FRAME_TYPE].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::FRAME_TYPE, f );
 
 		for ( const std::string & f : filterByFrameName.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::FRAME_NAME].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::FRAME_NAME, f );
 
 		for ( const std::string & f : filterByCommand.getValue ( ) )
-			filter[measurements::MeasurementProcessorFilterType::COMMAND].push_back ( f );
+			filter.add ( measurements::MeasurementProcessorFilter::FilterType::COMMAND, f );
 
 		auto processedResults = measurements::MeasurementProcessor::process ( results, filter );