BitField first Implement

metavis/GraphView.cpp

@@ -5,6 +5,7 @@
 #include <QBrush>
 #include <random>
 #include <algorithm>
+#include <chrono>
 
 #define X_AXIS_GAP_AMOUNT 5
 #define Y_AXIS_GAP_AMOUNT 10
@@ -18,7 +19,6 @@ GraphView::GraphView(QWidget* parent, QString title, Bound fixedBound):QWidget(p
 {
 	
 	linePen.setJoinStyle(Qt::PenJoinStyle::RoundJoin);
-	qDebug() << "minX:" << fixedBound.minX << " maxX:" << fixedBound.maxX << " minY:" << fixedBound.minY << " maxY:" << fixedBound.maxY;
 	rectPen.setWidth(0);
 	//Populate data with DummyData
 	//Draw Points
@@ -26,14 +26,10 @@ GraphView::GraphView(QWidget* parent, QString title, Bound fixedBound):QWidget(p
 	std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
 	std::uniform_real_distribution<double> doubleDistr(0.0, 1.0);
 	hueoffset = doubleDistr(gen);
-	QRect graphDisplayRect(rect());
-	graphDisplayRect.setBottom(graphDisplayRect.bottom() - 20);
-	graphDisplayRect.setLeft(graphDisplayRect.left() + 50);
-	graphDisplayRect.setTop(graphDisplayRect.top() + 20);
-	graphDisplayRect.setRight(graphDisplayRect.right() - 10);
-	graphDisplayRect.setWidth(graphDisplayRect.width() - (graphDisplayRect.width() % X_AXIS_GAP_AMOUNT) + 1);
-	graphDisplayRect.setHeight(graphDisplayRect.height() - (graphDisplayRect.height() % Y_AXIS_GAP_AMOUNT) + 1);
-	
+	setFocusPolicy(Qt::ClickFocus);
+	/*QTimer* timer = new QTimer(this);
+	connect(timer, &QTimer::timeout, this, QOverload<>::of(&GraphView::update));
+	timer->start(1000);*/
 }
 
 GraphView::~GraphView()
@@ -41,6 +37,7 @@ GraphView::~GraphView()
 }
 void GraphView::paintEvent(QPaintEvent* event)
 {
+	std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
 	QPainter painter(this);
 	painter.setRenderHint(QPainter::RenderHint::HighQualityAntialiasing);
 	if (graphSeriesVec.empty()) {
@@ -64,60 +61,59 @@ void GraphView::paintEvent(QPaintEvent* event)
 
 	double stregth_factorX = graphDisplayRect.width() / rangeGraphX;
 	double stregth_factorY = graphDisplayRect.height() / rangeGraphY;
-	for (GraphSeries graphSeries : graphSeriesVec) {
+	QPointF translation(graphDisplayRect.left(), graphDisplayRect.top());
+	for (const GraphSeries& graphSeries : graphSeriesVec) {
+		if (graphSeries.data->empty()) continue;
 		linePen.setColor(graphSeries.color);
 		painter.setPen(linePen);
-		QPointF translation(graphDisplayRect.left(), graphDisplayRect.top());
 
 		if (graphSeries.type == GraphSeries::SeriesType::Line || graphSeries.type == GraphSeries::SeriesType::LineDot) {
 			linePen.setWidth(graphSeries.lineWidth);
 			painter.setPen(linePen);
 			QPainterPath painterPath;
 
-			int i;
-			for (i = 0; i < graphSeries.data->size(); i++) {
-				QPointF& point = graphSeries.data->at(i);
-				/*if (!inBoundX(point)) continue;*/
-				painterPath.moveTo(transformPoint(point, stregth_factorX, stregth_factorY));
-				break;
-			}
-			for (; i < graphSeries.data->size(); i++) {
-				QPointF& point = graphSeries.data->at(i);
-				//if (!inBoundX(point)) break;
-				//if (point.y() > actualBound.maxY) {
-				//	//Generate new Point
-				//	QPointF& oldpoint = graphSeries.data->at(i - 1);
-				//	double xdif = std::abs(point.x() - oldpoint.x());
-				//	double ydif = std::abs(point.y() - oldpoint.y());
-				//	double newX = (xdif / ydif) * actualBound.maxY;
-				//	QPointF newPoint(newX, actualBound.maxY);
-				//	
-				//}
-				//else {
-
-				//}
-				painterPath.lineTo(transformPoint(point, stregth_factorX, stregth_factorY));
+			QPointF oldpoint = graphSeries.data->at(0).toQPointF();
+			painterPath.moveTo(transformPoint(oldpoint, stregth_factorX, stregth_factorY));
+			for (int i = 1; i < graphSeries.data->size(); i++) {
+				QPointF newpoint = graphSeries.data->at(i).toQPointF();
+				if (!inBoundX(oldpoint) && !inBoundX(newpoint)) {
+					
+				}
+				else if (!inBoundX(oldpoint) && inBoundX(newpoint)) {
+					painterPath.moveTo(transformPoint(oldpoint, stregth_factorX, stregth_factorY));
+					painterPath.lineTo(transformPoint(newpoint, stregth_factorX, stregth_factorY));
+				}
+				else if (inBoundX(oldpoint) && inBoundX(newpoint)) {
+					painterPath.lineTo(transformPoint(newpoint, stregth_factorX, stregth_factorY));
+				}
+				else if (inBoundX(oldpoint) && !inBoundX(newpoint)) {
+					painterPath.lineTo(transformPoint(newpoint, stregth_factorX, stregth_factorY));
+					break;
+				}
+				oldpoint = newpoint;
 			}
-			/*
-			std::pair<std::vector<QPointF>::iterator, std::vector<QPointF>::iterator> pair = graphSeries.getFirstLastIndexInSeriesThatsInBound(actualBound.minX, actualBound.maxX);
-			qDebug() << "hello";
-			painterPath.moveTo(transformPoint(*pair.first++, stregth_factorX, stregth_factorY));
-			for (std::vector<QPointF>::iterator it = pair.first; it != pair.second; it++) {
-				painterPath.lineTo(transformPoint(*it, stregth_factorX, stregth_factorY));
-			}*/
+
 			painterPath.translate(translation);
 			painter.drawPath(painterPath);
 		}
 		if (graphSeries.type == GraphSeries::SeriesType::Dot || graphSeries.type == GraphSeries::SeriesType::LineDot) {
 			painter.setBrush(graphSeries.color);
-			for (int i = 0; i < graphSeries.data->size(); i++) {
-				painter.drawEllipse(transformPoint(graphSeries.data->at(i), stregth_factorX, stregth_factorY) + translation, graphSeries.circleRadius, graphSeries.circleRadius);
+			for (auto data: *graphSeries.data) {
+				if (inBound(data.toQPointF())) {
+					painter.drawEllipse(transformPoint(data.toQPointF(), stregth_factorX, stregth_factorY) + translation, graphSeries.circleRadius, graphSeries.circleRadius);
+				}
 			}
 			painter.setBrush(Qt::BrushStyle::NoBrush);
 		}
 	}
 
 
+	if (drawTotalBound) {
+		painter.setPen(axisPen);
+		QRectF bounds(transformPoint(QPointF(totalBound.minX, totalBound.maxY), stregth_factorX, stregth_factorY), transformPoint(QPointF(totalBound.maxX, totalBound.minY), stregth_factorX, stregth_factorY));
+		bounds.translate(translation);
+		painter.drawRect(bounds);
+	}
 
 
 
@@ -134,8 +130,8 @@ void GraphView::paintEvent(QPaintEvent* event)
 	painter.drawRect(topRect);
 	painter.drawRect(bottomRect);
 	painter.drawRect(rightRect);
-	
 	painter.setBrush(Qt::BrushStyle::NoBrush);
+	
 	//painter.drawRect(yAxisRect);
 	
 	
@@ -174,13 +170,9 @@ void GraphView::paintEvent(QPaintEvent* event)
 		painter.drawText(textRect, Qt::AlignCenter, yAxisNumbers[i]);
 	}
 	painter.drawPath(yAxisPath);
-
-
-
-	qDebug() << "minX:" << actualBound.minX << " maxX:" << actualBound.maxX << " minY:" << actualBound.minY << " maxY:" << actualBound.maxY;
-
-
-	
+	std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
+	std::chrono::milliseconds time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+	qDebug() << "PaintTime: " << time.count() << "ms";
 }
 
 QPointF GraphView::transformPoint(QPointF& point, double stregth_factorX, double stregth_factorY) const
@@ -194,40 +186,44 @@ bool GraphView::inBoundX(QPointF& point)
 	return point.x() >= actualBound.minX && point.x() <= actualBound.maxX;
 }
 
+bool GraphView::inBoundY(QPointF& point)
+{
+	return point.y() >= actualBound.minY && point.y() <= actualBound.maxY;;
+}
+
+bool GraphView::inBound(QPointF& point)
+{
+	return inBoundX(point) && inBoundY(point);
+}
+
 void GraphView::keyPressEvent(QKeyEvent* event)
 {
 	switch (event->key()) {
 	case Qt::Key_Up:
-		qDebug() << "Up pressed";
 		fixedBound.move(this, Bound::Change::MoveUp);
 		break;
 	case Qt::Key_Right:
-		qDebug() << "Right pressed";
 		fixedBound.move(this, Bound::Change::MoveRight);
 		break;
 	case Qt::Key_Left:
-		qDebug() << "Key_Left pressed";
 		fixedBound.move(this, Bound::Change::MoveLeft);
 		break;
 	case Qt::Key_Down:
-		qDebug() << "Key_Down pressed";
 		fixedBound.move(this, Bound::Change::MoveDown);
 		break;
 	case Qt::Key_PageUp:
 	case Qt::Key_Plus:
-		qDebug() << "Key_Down pressed";
 		fixedBound.move(this, Bound::Change::ZoomIn);
 		break;
 	case Qt::Key_PageDown:
 	case Qt::Key_Minus:
-		qDebug() << "Key_Down pressed";
 		fixedBound.move(this, Bound::Change::ZoomOut);
 		break;
 	case Qt::Key_R:
 		fixedBound = totalBound;
 		calculateRangeXY();
 		generateAxisNumberStrings();
-		repaint();
+		update();
 	default:
 		QWidget::keyPressEvent(event);
 	}
@@ -242,7 +238,6 @@ void GraphView::wheelEvent(QWheelEvent* event)
 
 	if (!numPixels.isNull()) {
 		//scrollWithPixels(numPixels);
-		qDebug() << "NumPixels:" << numPixels;
 		switch (numPixels.y()) {
 		case -1:
 			fixedBound.move(this, Bound::Change::ZoomIn);
@@ -255,14 +250,11 @@ void GraphView::wheelEvent(QWheelEvent* event)
 	}
 	else if (!numDegrees.isNull()) {
 		QPoint numSteps = numDegrees / 15;
-		qDebug() << "numSteps:" << numSteps;
 		switch (numSteps.y()) {
 		case 1:
-			qDebug() << "ZoomIn";
 			fixedBound.move(this, Bound::Change::ZoomIn);
 			break;
 		case -1:
-			qDebug() << "ZoomOut";
 			fixedBound.move(this, Bound::Change::ZoomOut);
 		default:
 			break;
@@ -272,9 +264,54 @@ void GraphView::wheelEvent(QWheelEvent* event)
 	event->accept();
 }
 
+void GraphView::mouseMoveEvent(QMouseEvent* event)
+{
+	//QToolTip::showText(event->globalPos(), "Hello", this);
+	QPointF delta = event->pos() - oldPos;
+	oldPos = event->pos();
+	double rangeX = std::abs(actualBound.maxX - actualBound.minX);
+	int width =  (rect().right() - 10) - (rect().left() + 50);
+	width -= (width % X_AXIS_GAP_AMOUNT) + 1;
+	double pixelWidthX = rangeX / (double)width ;
+	double rangeY = std::abs(actualBound.maxY - actualBound.minY);
+	int height = (rect().bottom() - 20) - (rect().top() + 20);
+	height -= (height % Y_AXIS_GAP_AMOUNT) + 1;
+	double pixelWidthY = rangeY / (double)height;
+
+
+
+	fixedBound.move(this, delta, pixelWidthX, pixelWidthY);
+
+}
+
+void GraphView::mousePressEvent(QMouseEvent* event)
+{
+	QString string = "Pos (" + QString::number(event->pos().x()) + "," + QString::number(event->pos().y()) + ")";
+	//QString printable = QStringLiteral("Pos(%d,%d)").arg(event->pos().x(), event->pos().y());
+	QToolTip::showText(event->globalPos() - QPoint(0, 35), string);
+	oldPos = event->pos();
+}
+
+void GraphView::mouseReleaseEvent(QMouseEvent* event)
+{
+
+}
+
+void GraphView::update()
+{
+	calculateRangeXY();
+	generateAxisNumberStrings();
+	QWidget::update();
+}
+
+void GraphView::setDrawBound(bool value)
+{
+	drawTotalBound = value;
+}
+
+
 void GraphView::calculateTotalGraphBound()
 {
-	qDebug() << "calculateTotalGraphBound";
 	totalBound.minX = std::min_element(std::begin(graphSeriesVec), std::end(graphSeriesVec), [](const GraphSeries& a, const GraphSeries& b) -> bool {return a.minX < b.minX; })->minX;
 	totalBound.maxX = std::max_element(std::begin(graphSeriesVec), std::end(graphSeriesVec), [](const GraphSeries& a, const GraphSeries& b) -> bool {return a.maxX < b.maxX; })->maxX;
 	totalBound.minY = std::min_element(std::begin(graphSeriesVec), std::end(graphSeriesVec), [](const GraphSeries& a, const GraphSeries& b) -> bool {return a.minY < b.minY; })->minY;
@@ -284,10 +321,7 @@ void GraphView::calculateTotalGraphBound()
 
 void GraphView::calculateRangeXY()
 {
-	qDebug() << "calculateRangeXY";
 	actualBound = useFixedBound ? fixedBound : totalBound;
-	qDebug() << "calculateRangeXY  " << "minX:" << actualBound.minX << " maxX:" << actualBound.maxX << " minY:" << actualBound.minY << " maxY:" << actualBound.maxY;
-
 	rangeGraphX = std::abs(actualBound.maxX - actualBound.minX);
 	rangeGraphY = std::abs(actualBound.maxY - actualBound.minY);
 	if (std::abs(rangeGraphX) < 0.01) {
@@ -305,19 +339,18 @@ void GraphView::calculateRangeXY()
 //TODO: graphview 
 void GraphView::calculateMinMaxXY(GraphSeries& lgs)
 {
-	qDebug() << "calculateMinMaxXY";
-	auto pairX = std::minmax_element(lgs.data->begin(), lgs.data->end(), [](const QPointF& a, const QPointF& b) -> bool {return a.x() < b.x(); });
-	lgs.minX = pairX.first->x();
-	lgs.maxX = pairX.second->x();
-	auto pairY = std::minmax_element(lgs.data->begin(), lgs.data->end(), [](const QPointF& a, const QPointF& b) -> bool {return a.y() < b.y(); });
-	lgs.minY = pairY.first->y();
-	lgs.maxY = pairY.second->y();
+	auto pairX = std::minmax_element(lgs.data->begin(), lgs.data->end(), [](const GraphDataPoint& a, const GraphDataPoint& b) -> bool {return a.x < b.x; });
+	lgs.minX = pairX.first->x;
+	lgs.maxX = pairX.second->x;
+	auto pairY = std::minmax_element(lgs.data->begin(), lgs.data->end(), [](const GraphDataPoint& a, const GraphDataPoint& b) -> bool {return a.y < b.y; });
+	lgs.minY = pairY.first->y;
+	lgs.maxY = pairY.second->y;
 }
 
-void GraphView::addSeries(std::vector<QPointF>& line, QColor color, GraphSeries::SeriesType type)
+void GraphView::addSeries(std::vector<GraphDataPoint>& line, QColor color, GraphSeries::SeriesType type)
 {
-	qDebug() << "addSeries";
 	if (line.empty()) {
+		qDebug() << "Series is empty!";
 		return;
 	}
 	GraphSeries lgs;
@@ -329,8 +362,6 @@ void GraphView::addSeries(std::vector<QPointF>& line, QColor color, GraphSeries:
 	calculateTotalGraphBound();
 	if (!useFixedBound) calculateRangeXY();
 	generateAxisNumberStrings();
-	qDebug() << "addSeries  " << "minX:" << actualBound.minX << " maxX:" << actualBound.maxX << " minY:" << actualBound.minY << " maxY:" << actualBound.maxY;
-
 }
 
 QColor GraphView::generateNextColorForGraph()
@@ -348,8 +379,6 @@ void GraphView::generateAxisNumberStrings()
 		xAxisNumbers[i] = QString::number(actualBound.minX + i * (rangeGraphX / (double)X_AXIS_GAP_AMOUNT), 'f', 1);
 		yAxisNumbers[i] = QString::number(actualBound.minY + i * (rangeGraphY / (double)Y_AXIS_GAP_AMOUNT), 'f', 1);
 	}
-	qDebug() << "generateAxisNumberStrings  " << "minX:" << actualBound.minX << " maxX:" << actualBound.maxX << " minY:" << actualBound.minY << " maxY:" << actualBound.maxY;
-
 }
 
 void GraphView::setUseFixedBound(bool value)
@@ -373,41 +402,36 @@ void GraphView::generateAndAddRandomLine()
 	std::uniform_int_distribution<int> intScaleDistr(1, 3);
 
 	for (int randomSeries = 0; randomSeries < 1; randomSeries++) {
-		std::vector<QPointF> randomPointVec(101);
+		std::vector<GraphDataPoint> randomPointVec(101);
 		int scale = intScaleDistr(gen);
 		for (int i = 0; i < randomPointVec.size(); i++) {
-			randomPointVec[i] = QPointF(i + 500, i * scale + realDistr(gen));
+			randomPointVec[i] = GraphDataPoint(i + 500, i * scale + realDistr(gen));
 		}
 		addLine(randomPointVec);
 	}
 }
 
-void GraphView::addLine(std::vector<QPointF>& line)
+void GraphView::addLine(std::vector<GraphDataPoint>& line)
 {
 	addSeries(line, generateNextColorForGraph(), GraphSeries::SeriesType::Line);
 }
 
-void GraphView::addLine(std::vector<QPointF>& line, QColor color)
+void GraphView::addLine(std::vector<GraphDataPoint>& line, QColor color)
 {
 	addSeries(line, color, GraphSeries::SeriesType::Line);
 }
 
-void GraphView::addDots(std::vector<QPointF>& dots)
+void GraphView::addDots(std::vector<GraphDataPoint>& dots)
 {
 	addSeries(dots, generateNextColorForGraph(), GraphSeries::SeriesType::Dot);
 }
 
-void GraphView::addDots(std::vector<QPointF>& dots, QColor color)
+void GraphView::addDots(std::vector<GraphDataPoint>& dots, QColor color)
 {
 	addSeries(dots, color, GraphSeries::SeriesType::Dot);
 }
 
-std::pair<std::vector<QPointF>::iterator , std::vector<QPointF>::iterator> GraphSeries::getFirstLastIndexInSeriesThatsInBound(int minX, int maxX)
-{
-	std::vector<QPointF>::iterator minIter = std::find_if(data->begin(), data->end(), [minX](const QPointF& p) -> bool {return p.x() >= minX; });
-	std::vector<QPointF>::iterator maxIter = std::find_if(minIter, data->end(), [maxX](const QPointF& p) -> bool {return p.x() > maxX; });
-	return std::make_pair(minIter, --maxIter);
-}
+
 
 void Bound::move(GraphView* widget,const Change& type, const double changePercentage)
 {
@@ -445,7 +469,30 @@ void Bound::move(GraphView* widget,const Change& type, const double changePercen
 	default:
 		break;
 	}
-	widget->calculateRangeXY();
-	widget->generateAxisNumberStrings();
-	widget->repaint();
+	//TODO: Move out of bound in calculate widget
+	widget->update();
+}
+
+void Bound::move(GraphView* widget, QPointF& delta, double realPixelWidthX, double realPixelWidthY)
+{
+	minX += -delta.x() * realPixelWidthX;
+	maxX += -delta.x() * realPixelWidthX;
+	minY += delta.y() * realPixelWidthY;
+	maxY += delta.y() * realPixelWidthY;
+	widget->update();
+}
+
+GraphDataPoint::GraphDataPoint(double x, double y, SolutionPointData* orginalPoint) : x(x), y(y), orginalPoint(orginalPoint)
+{
+
+}
+
+bool GraphDataPoint::existLink()
+{
+	return orginalPoint != nullptr;
+}
+
+QPointF GraphDataPoint::toQPointF()
+{
+	return QPointF(x, y);
 }

metavis/GraphView.h

@@ -4,18 +4,33 @@
 #include <QPen>
 #include <QPainter>
 #include <vector>
+#include "RunData.h"
+
 class GraphView;
+struct SolutionPointData;
+struct GraphDataPoint {
+	double x;
+	double y;
+	SolutionPointData* orginalPoint;
+	QColor color;
+	GraphDataPoint():x(0),y(0), orginalPoint(nullptr){}
+	GraphDataPoint(double x, double y, SolutionPointData* orginalPoint = nullptr);
+	bool existLink();
+	QPointF toQPointF();
+};
 struct GraphSeries {
-	std::vector<QPointF>* data;
+	std::vector<GraphDataPoint>* data;
 	double minX, maxX;
 	double minY, maxY;
+
+	//Settings for visual
 	QString name;
 	QColor color;
 	int lineWidth = 2;
-	double circleRadius = 1.0;
+	double circleRadius = 2.0;
 	enum class SeriesType{ Line, Dot, LineDot};
+	bool useDataPointColor = false;
 	SeriesType type;
-	std::pair<std::vector<QPointF>::iterator, std::vector<QPointF>::iterator> getFirstLastIndexInSeriesThatsInBound(int minX, int maxX);
 };
 
 struct Bound {
@@ -24,6 +39,7 @@ struct Bound {
 	Bound() {}
 	Bound(double minX, double maxX, double minY, double maxY):minX(minX), maxX(maxX), minY(minY), maxY(maxY){}
 	void move(GraphView* widget,const Change& type, const double changePercentage = 0.1);
+	void move(GraphView* widget, QPointF& delta, double realPixelWidthX, double realPixelWidthY);
 };
 
 class GraphView :public QWidget
@@ -42,6 +58,7 @@ private:
 	std::vector<GraphSeries> graphSeriesVec;
 	Bound totalBound;
 	Bound actualBound = totalBound;
+	bool drawTotalBound = false;
 	double rangeGraphX = 0, rangeGraphY = 0;
 	
 	
@@ -57,21 +74,28 @@ private:
 public:
 	void setUseFixedBound(bool value);
 	void generateAndAddRandomLine();
-	void addLine(std::vector<QPointF>& line);
-	void addLine(std::vector<QPointF>& line, QColor color);
-	void addDots(std::vector<QPointF>& dots);
-	void addDots(std::vector<QPointF>& dots, QColor color);
+	void addLine(std::vector<GraphDataPoint>& line);
+	void addLine(std::vector<GraphDataPoint>& line, QColor color);
+	void addDots(std::vector<GraphDataPoint>& dots);
+	void addDots(std::vector<GraphDataPoint>& dots, QColor color);
 	void calculateRangeXY();
 	void generateAxisNumberStrings();
+	void update();
+	void setDrawBound(bool value);
 private:
 	void calculateTotalGraphBound();
 	void GraphView::calculateMinMaxXY(GraphSeries& lgs);
-	void addSeries(std::vector<QPointF>& line, QColor color, GraphSeries::SeriesType type);
+	void addSeries(std::vector<GraphDataPoint>& line, QColor color, GraphSeries::SeriesType type);
 	QColor generateNextColorForGraph();
 	QPointF transformPoint(QPointF& point, double stregth_factorX, double stregth_factorY) const;
 	bool inBoundX(QPointF& point);
+	bool inBoundY(QPointF& point);
+	bool inBound(QPointF& point);
 	void keyPressEvent(QKeyEvent* event) override;
 	void wheelEvent(QWheelEvent* event) override;
-
+	void mouseMoveEvent(QMouseEvent* event) override;
+	void mousePressEvent(QMouseEvent* event) override;
+	void mouseReleaseEvent(QMouseEvent* event) override;
+	QPointF oldPos;
 };
 

metavis/RunData.cpp

@@ -49,12 +49,26 @@ RunData::RunData(std::string filePath): fileStream(filePath)
             return;
         }
         sol.particleNumber = std::stoi(match[1]);
+        std::regex regexBitVec("b:([01]+)");
+        if(!std::regex_search(buffer, match, regexBitVec)) {
+            qDebug() << "Bad formatatted Line[" << actualLine << "].";
+            qDebug() << "Failed to matched:";
+            qDebug() << QString::fromStdString(buffer);
+            return;
+        }
+        sol.bitVec.resize(match[1].length());
+        int count = 0;
+        std::string str = match[1];
+        for (std::string::size_type i = 0; i < str.size(); ++i) {
+            sol.bitVec[i] = (str[i] == '1');
+        }
         solutionVec.push_back(sol);
     }
     fileStream.close();
     calculateBestAndAverageIter();
     calculateParticleSolution();
     calculateDotsForDistribution();
+    generateRandomBitFieldData();
 }
 
 void RunData::getLine(std::string& bufferString)
@@ -78,10 +92,10 @@ void RunData::calculateBestAndAverageIter()
         SolutionPointData nextData = solutionVec[i];
         if (nextData.iteration != actualIter) {
             //save last
-            bestSolutionPerIteration.push_back(QPointF((double)actualIter, bestObjectiveFunctionFound));
-            averageSolutionPerItertion.push_back(QPointF((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
-            minSolutionPerItertion.push_back(QPointF((double)actualIter, minObjectiveFunctionInIter));
-            maxSolutionPerItertion.push_back(QPointF((double)actualIter, maxObjectiveFunctionInIter));
+            bestSolutionPerIteration.push_back(GraphDataPoint((double)actualIter, bestObjectiveFunctionFound));
+            averageSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
+            minSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, minObjectiveFunctionInIter));
+            maxSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, maxObjectiveFunctionInIter));
             //init new iteration
             actualIter = nextData.iteration;
             foundSolutionInIteration = 1;
@@ -106,10 +120,10 @@ void RunData::calculateBestAndAverageIter()
         }
     }
     //save last iteration
-    bestSolutionPerIteration.push_back(QPointF((double)actualIter, bestObjectiveFunctionFound));
-    averageSolutionPerItertion.push_back(QPointF((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
-    minSolutionPerItertion.push_back(QPointF((double)actualIter, minObjectiveFunctionInIter));
-    maxSolutionPerItertion.push_back(QPointF((double)actualIter, maxObjectiveFunctionInIter));
+    bestSolutionPerIteration.push_back(GraphDataPoint((double)actualIter, bestObjectiveFunctionFound));
+    averageSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
+    minSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, minObjectiveFunctionInIter));
+    maxSolutionPerItertion.push_back(GraphDataPoint((double)actualIter, maxObjectiveFunctionInIter));
 
 
 }
@@ -117,11 +131,11 @@ void RunData::calculateBestAndAverageIter()
 void RunData::calculateParticleSolution()
 {
     for (SolutionPointData sol : solutionVec) {
-        QPointF point(sol.iteration, sol.objectiveFunction);
+        GraphDataPoint point(sol.iteration, sol.objectiveFunction, &sol);
         auto iter = particleMap.find(sol.particleNumber);
         if (iter == particleMap.end()) {
             //create new Entry
-            std::vector<QPointF> vec;
+            std::vector<GraphDataPoint> vec;
             vec.push_back(point);
             particleMap.insert({ sol.particleNumber, vec});
         }
@@ -135,6 +149,13 @@ void RunData::calculateParticleSolution()
 void RunData::calculateDotsForDistribution()
 {
     for (SolutionPointData sol : solutionVec) {
-        dotsForDistribution.push_back(QPointF((double)sol.iteration, sol.objectiveFunction));
+        dotsForDistribution.push_back(GraphDataPoint((double)sol.iteration, sol.objectiveFunction, &sol));
+    }
+}
+
+void RunData::generateRandomBitFieldData()
+{
+    for (SolutionPointData sol : solutionVec) {
+        testForBitField.push_back(GraphDataPoint(0.5, std::count(sol.bitVec.begin(), sol.bitVec.end(), true)));
     }
 }

metavis/RunData.h

@@ -4,13 +4,19 @@
 #include <fstream>
 #include <QPoint>
 #include <map>
+#include "GraphView.h"
 
+
+
+
+struct GraphDataPoint;
 struct SolutionPointData {
-public:
 	int iteration;
 	double objectiveFunction;
 	int particleNumber;
+	std::vector<bool> bitVec;
 };
+
 class RunData
 {
 public:
@@ -21,12 +27,13 @@ public:
 	RunData(std::string filePath);
 	
 
-	std::vector<QPointF> bestSolutionPerIteration;
-	std::vector<QPointF> averageSolutionPerItertion;
-	std::vector<QPointF> minSolutionPerItertion;
-	std::vector<QPointF> maxSolutionPerItertion;
-	std::vector<QPointF> dotsForDistribution;
-	std::map<int, std::vector<QPointF>> particleMap;
+	std::vector<GraphDataPoint> bestSolutionPerIteration;
+	std::vector<GraphDataPoint> averageSolutionPerItertion;
+	std::vector<GraphDataPoint> minSolutionPerItertion;
+	std::vector<GraphDataPoint> maxSolutionPerItertion;
+	std::vector<GraphDataPoint> dotsForDistribution;
+	std::vector<GraphDataPoint> testForBitField;
+	std::map<int, std::vector<GraphDataPoint>> particleMap;
 private:
 	bool badFileFlag = false;
 	std::fstream fileStream;
@@ -36,6 +43,7 @@ private:
 	void calculateBestAndAverageIter();
 	void calculateParticleSolution();
 	void calculateDotsForDistribution();
+	void generateRandomBitFieldData();
 
 };
 

metavis/metavis.cpp

@@ -12,7 +12,7 @@
 #include <QFileDialog>
 #include <QDir>
 #include <map>
-
+#include <boost/multiprecision/cpp_int.hpp>
 #include <QDesktopWidget>
 
 metavis::metavis(QWidget* parent)
@@ -23,10 +23,16 @@ metavis::metavis(QWidget* parent)
 	settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, "TK", "metavis", this);
 	setStyleSheet(styleSheet() + "QMainWindow::separator {background: rgb(200, 200, 200);width: 1px;height: 1px;}");
 	setStyleSheet(styleSheet() + "QTabBar::tab:selected {color: rgb(0, 122, 204);}");
-	setStyleSheet(styleSheet() + "QTabWidget::pane {border-top: 2px solid #C2C7CB;}");
+	setStyleSheet(styleSheet() + "QTabWidget::pane {border-top: 0px solid #C2C7CB;margin: -9px -9px -13px -9px;}");
 
 	readMainWindowSettings();
-}
+	
+
+
+	qDebug() << "Test Boost";
+	boost::multiprecision::cpp_int bla = 1;
+	createBitField();
+} 
 
 
 
@@ -51,7 +57,6 @@ GraphView* metavis::createCustomWidget(QString titleString)
 	GraphView* graph = new GraphView(dock, titleString, Bound(10, 20, 40.0, 50.0));
 	graph->setUseFixedBound(true);
 	graph->setMinimumSize(200, 200);
-	graph->setFocusPolicy(Qt::ClickFocus);
 	graph->show();
 	graph->repaint();
 	dock->setWidget(graph);
@@ -59,6 +64,17 @@ GraphView* metavis::createCustomWidget(QString titleString)
 	return graph;
 }
 
+void metavis::createBitField()
+{
+	bitField = new GraphView(this, "BitField", Bound(0.0, 1.0, 0.0, 1600.0));
+	bitField->setUseFixedBound(true);
+	bitField->setMinimumSize(200, 200);
+	//this->setCentralWidget(bitField);
+	QHBoxLayout* layout = new QHBoxLayout;
+	layout->addWidget(bitField);
+	ui.BitFieldWidget->setLayout(layout);
+}
+
 void metavis::writeActualMainWindowSettings()
 {
 	settings->beginGroup("MainWindow");
@@ -111,5 +127,6 @@ void metavis::openFile()
 	for (auto iter = runVec[0].particleMap.begin(); iter != runVec[0].particleMap.end(); iter++) {
 		particleGraph->addLine(iter->second);
 	}
-
+	//Test
+	bitField->addDots(runVec[0].testForBitField, QColor(255, 165, 0, 100));
 }

metavis/metavis.h

@@ -19,6 +19,7 @@ public:
 	GraphView* bestGraph;
 	GraphView* particleGraph;
 	GraphView* minMaxGraph;
+	GraphView* bitField;
 private:
 	Ui::metavisClass ui;
 	QSettings* settings;
@@ -28,6 +29,7 @@ private:
 private:
 	/* Widget functions */
 	GraphView* createCustomWidget(QString titleString);
+	void createBitField();
 
 
 	/* Setting functions*/

metavis/metavis.ui

@@ -13,7 +13,37 @@
   <property name="windowTitle">
    <string>metavis</string>
   </property>
-  <widget class="QWidget" name="centralWidget"/>
+  <widget class="QWidget" name="centralWidget">
+   <layout class="QHBoxLayout" name="horizontalLayout">
+    <property name="spacing">
+     <number>0</number>
+    </property>
+    <property name="leftMargin">
+     <number>0</number>
+    </property>
+    <property name="topMargin">
+     <number>0</number>
+    </property>
+    <property name="rightMargin">
+     <number>0</number>
+    </property>
+    <property name="bottomMargin">
+     <number>0</number>
+    </property>
+    <item>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="styleSheet">
+       <string notr="true"> margin: -13px -9px -13px -9px;</string>
+      </property>
+      <widget class="QWidget" name="BitFieldWidget">
+       <attribute name="title">
+        <string>BitField</string>
+       </attribute>
+      </widget>
+     </widget>
+    </item>
+   </layout>
+  </widget>
   <widget class="QMenuBar" name="menuBar">
    <property name="geometry">
     <rect>

metavis/metavis.vcxproj

@@ -71,6 +71,7 @@
       <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\boost\boost_1_72_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -88,6 +89,7 @@
       <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories>C:\Program Files %28x86%29\boost\boost_1_72_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -105,7 +107,6 @@
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
     </ClCompile>
-    <ClCompile Include="QTestGraph.cpp" />
     <ClCompile Include="RunData.cpp" />
     <ClCompile Include="SettingDialog.cpp" />
   </ItemGroup>
@@ -127,7 +128,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="pch.h" />
-    <ClInclude Include="QTestGraph.h" />
     <ClInclude Include="RunData.h" />
     <QtMoc Include="GraphView.h" />
   </ItemGroup>

metavis/metavis.vcxproj.filters

@@ -43,9 +43,6 @@
     <ClCompile Include="pch.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="QTestGraph.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <QtMoc Include="metavis.h">
@@ -81,8 +78,5 @@
     <ClInclude Include="pch.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="QTestGraph.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

metavis/pch.h

@@ -20,8 +20,8 @@
 #include <QFileDialog>
 #include <QDir>
 #include <QString>
-
-
+#include <QToolTip>
+#include <QTimer>
 
 //Std
 #include <vector>