OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#3297 Make casing shoe a right-angled triangle and refactor symbols

Browse Source 
* Put plot symbol enum inside the symbol class.
* Put line style enums inside the line class.
* Add custom capability.
This commit is contained in:
Gaute Lindkvist
2018-09-04 09:08:29 +02:00
parent e3baaa4133
commit 12484bf1e9
35 changed files with 468 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Commands/SummaryPlotCommands/RicPasteAsciiDataToSummaryPlotFeatureUi.cpp
View File

@@ -167,8 +167,8 @@ RicPasteAsciiDataToSummaryPlotFeatureUi::RicPasteAsciiDataToSummaryPlotFeatureUi
CAF_PDM_InitField(&m_useCustomDateFormat, "UseCustomDateFormat", false, "Use Custom Date Time Format", "", "", "");
CAF_PDM_InitField(&m_customDateTimeFormat,"CustomDateTimeFormat", QString(), "Custom Date Time Format", "", DATETIME_FORMAT_TOOLTIP, "");
CAF_PDM_InitField(&m_curveLineStyle, "LineStyle", caf::AppEnum<RimPlotCurve::LineStyleEnum>(RimPlotCurve::STYLE_NONE), "Line Style", "", "", "");
CAF_PDM_InitField(&m_curveSymbol, "Symbol", caf::AppEnum<RimPlotCurve::PointSymbolEnum>(RimPlotCurve::SYMBOL_ELLIPSE), "Symbol", "", "", "");
CAF_PDM_InitField(&m_curveLineStyle, "LineStyle", caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum>(RiuQwtPlotCurve::STYLE_NONE), "Line Style", "", "", "");
CAF_PDM_InitField(&m_curveSymbol, "Symbol", caf::AppEnum<RiuQwtSymbol::PointSymbolEnum>(RiuQwtSymbol::SYMBOL_ELLIPSE), "Symbol", "", "", "");
CAF_PDM_InitField(&m_curveSymbolSkipDistance, "SymbolSkipDinstance", 0.0f, "Symbol Skip Distance", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_cellSeparator, "CellSeparator", "Cell Separator", "", "", "");

8
ApplicationCode/Commands/SummaryPlotCommands/RicPasteAsciiDataToSummaryPlotFeatureUi.h
View File

@@ -55,8 +55,8 @@ public:
bool assumeNumericDataColumns;
RimPlotCurve::LineStyleEnum curveLineStyle;
RimPlotCurve::PointSymbolEnum curveSymbol;
RiuQwtPlotCurve::LineStyleEnum curveLineStyle;
RiuQwtSymbol::PointSymbolEnum curveSymbol;
float curveSymbolSkipDistance;
};
@@ -148,8 +148,8 @@ private:
caf::PdmField<CellSeparatorEnum> m_cellSeparator;
caf::PdmField<QString> m_timeSeriesColumnName;
caf::PdmField<caf::AppEnum<RimPlotCurve::LineStyleEnum>> m_curveLineStyle;
caf::PdmField<caf::AppEnum<RimPlotCurve::PointSymbolEnum>> m_curveSymbol;
caf::PdmField<caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum>> m_curveLineStyle;
caf::PdmField<caf::AppEnum<RiuQwtSymbol::PointSymbolEnum>> m_curveSymbol;
caf::PdmField<float> m_curveSymbolSkipDistance;
bool m_createNewPlot;

4
ApplicationCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp
View File

@@ -198,7 +198,7 @@ void RicNewWellBoreStabilityPlotFeature::createStabilityCurvesTrack(RimWellLogPl
std::vector<QString> resultNames = RiaDefines::wellPathStabilityResultNames();
std::vector<cvf::Color3f> colors = { cvf::Color3f::RED, cvf::Color3f::PURPLE, cvf::Color3f::GREEN, cvf::Color3f::BLUE, cvf::Color3f::ORANGE };
std::vector<RimPlotCurve::LineStyleEnum> lineStyles = { RimPlotCurve::STYLE_SOLID, RimPlotCurve::STYLE_DASH, RimPlotCurve::STYLE_DASH_DOT, RimPlotCurve::STYLE_SOLID, RimPlotCurve::STYLE_DASH};
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = { RiuQwtPlotCurve::STYLE_SOLID, RiuQwtPlotCurve::STYLE_DASH, RiuQwtPlotCurve::STYLE_DASH_DOT, RiuQwtPlotCurve::STYLE_SOLID, RiuQwtPlotCurve::STYLE_DASH};
for (size_t i = 0; i < resultNames.size(); ++i)
{
@@ -229,7 +229,7 @@ void RicNewWellBoreStabilityPlotFeature::createAnglesTrack(RimWellLogPlot* plot,
std::vector<cvf::Color3f> colors = { cvf::Color3f::DARK_RED, cvf::Color3f::BLUE };
std::vector<RimPlotCurve::LineStyleEnum> lineStyles = { RimPlotCurve::STYLE_SOLID, RimPlotCurve::STYLE_DASH };
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = { RiuQwtPlotCurve::STYLE_SOLID, RiuQwtPlotCurve::STYLE_DASH };
for (size_t i = 0; i < resultNames.size(); ++i)
{

2
ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp
View File

@@ -26,7 +26,7 @@
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "qwt_plot.h"

2
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@@ -725,7 +725,7 @@ void RimWellPltPlot::addStackedCurve(const QString& curveName,
if (curveGroupId == 0)
{
curve->setDoFillCurve(true);
curve->setSymbol(RimPlotCurve::SYMBOL_NONE);
curve->setSymbol(RiuQwtSymbol::SYMBOL_NONE);
}
else
{

22
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@@ -141,25 +141,25 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
std::vector<RimPlotCurve::PointSymbolEnum> symbolTable = {RimPlotCurve::SYMBOL_ELLIPSE,
RimPlotCurve::SYMBOL_RECT,
RimPlotCurve::SYMBOL_DIAMOND,
RimPlotCurve::SYMBOL_TRIANGLE,
RimPlotCurve::SYMBOL_CROSS,
RimPlotCurve::SYMBOL_XCROSS};
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_TRIANGLE,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS};
// State variables
static size_t defaultColorTableIndex = 0;
static size_t defaultSymbolTableIndex = 0;
cvf::Color3f currentColor;
RimPlotCurve::PointSymbolEnum currentSymbol = symbolTable.front();
RimPlotCurve::LineStyleEnum currentLineStyle = RimPlotCurve::STYLE_SOLID;
RiuQwtSymbol::PointSymbolEnum currentSymbol = symbolTable.front();
RiuQwtPlotCurve::LineStyleEnum currentLineStyle = RiuQwtPlotCurve::STYLE_SOLID;
bool isCurrentColorSet = false;
bool isCurrentSymbolSet = false;
std::set<cvf::Color3f> assignedColors;
std::set<RimPlotCurve::PointSymbolEnum> assignedSymbols;
std::set<RiuQwtSymbol::PointSymbolEnum> assignedSymbols;
// Used colors and symbols
for (RimWellLogCurve* const curve : m_wellLogPlot->trackByIndex(0)->curvesVector())
@@ -220,8 +220,8 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
}
// Observed data
currentLineStyle = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ? RimPlotCurve::STYLE_NONE
: RimPlotCurve::STYLE_SOLID;
currentLineStyle = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ? RiuQwtPlotCurve::STYLE_NONE
: RiuQwtPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
newCurve->setSymbol(currentSymbol);

2
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp
View File

@@ -40,7 +40,7 @@
#include "RimSummaryTimeAxisProperties.h"
#include "RiuFemTimeHistoryResultAccessor.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuSelectionManager.h"
#include "qwt_plot.h"

171
ApplicationCode/ProjectDataModel/RimPlotCurve.cpp
View File

@@ -41,41 +41,42 @@ CAF_PDM_XML_ABSTRACT_SOURCE_INIT(RimPlotCurve, "PlotCurve");
namespace caf
{
template<>
void caf::AppEnum< RimPlotCurve::LineStyleEnum >::setUp()
{
addItem(RimPlotCurve::STYLE_NONE, "STYLE_NONE", "None");
addItem(RimPlotCurve::STYLE_SOLID, "STYLE_SOLID", "Solid");
addItem(RimPlotCurve::STYLE_DASH, "STYLE_DASH", "Dashes");
addItem(RimPlotCurve::STYLE_DOT, "STYLE_DOT", "Dots");
addItem(RimPlotCurve::STYLE_DASH_DOT, "STYLE_DASH_DOT", "Dashes and Dots");
setDefault(RimPlotCurve::STYLE_SOLID);
}
template<>
void caf::AppEnum< RimPlotCurve::PointSymbolEnum >::setUp()
{
addItem(RimPlotCurve::SYMBOL_NONE, "SYMBOL_NONE", "None");
addItem(RimPlotCurve::SYMBOL_ELLIPSE, "SYMBOL_ELLIPSE", "Ellipse");
addItem(RimPlotCurve::SYMBOL_RECT, "SYMBOL_RECT", "Rect");
addItem(RimPlotCurve::SYMBOL_DIAMOND, "SYMBOL_DIAMOND", "Diamond");
addItem(RimPlotCurve::SYMBOL_TRIANGLE, "SYMBOL_TRIANGLE", "Triangle");
addItem(RimPlotCurve::SYMBOL_CROSS, "SYMBOL_CROSS", "Cross");
addItem(RimPlotCurve::SYMBOL_XCROSS, "SYMBOL_XCROSS", "X Cross");
setDefault(RimPlotCurve::SYMBOL_NONE);
}
template<>
void RimPlotCurve::CurveInterpolation::setUp()
{
addItem(RimPlotCurve::INTERPOLATION_POINT_TO_POINT, "INTERPOLATION_POINT_TO_POINT", "Point to Point");
addItem(RimPlotCurve::INTERPOLATION_STEP_LEFT, "INTERPOLATION_STEP_LEFT", "Step Left");
addItem(RiuQwtPlotCurve::INTERPOLATION_POINT_TO_POINT, "INTERPOLATION_POINT_TO_POINT", "Point to Point");
addItem(RiuQwtPlotCurve::INTERPOLATION_STEP_LEFT, "INTERPOLATION_STEP_LEFT", "Step Left");
setDefault(RimPlotCurve::INTERPOLATION_POINT_TO_POINT);
setDefault(RiuQwtPlotCurve::INTERPOLATION_POINT_TO_POINT);
}
template<>
void RimPlotCurve::LineStyle::setUp()
{
addItem(RiuQwtPlotCurve::STYLE_NONE, "STYLE_NONE", "None");
addItem(RiuQwtPlotCurve::STYLE_SOLID, "STYLE_SOLID", "Solid");
addItem(RiuQwtPlotCurve::STYLE_DASH, "STYLE_DASH", "Dashes");
addItem(RiuQwtPlotCurve::STYLE_DOT, "STYLE_DOT", "Dots");
addItem(RiuQwtPlotCurve::STYLE_DASH_DOT, "STYLE_DASH_DOT", "Dashes and Dots");
setDefault(RiuQwtPlotCurve::STYLE_SOLID);
}
template<>
void RimPlotCurve::PointSymbol::setUp()
{
addItem(RiuQwtSymbol::SYMBOL_NONE, "SYMBOL_NONE", "None");
addItem(RiuQwtSymbol::SYMBOL_ELLIPSE, "SYMBOL_ELLIPSE", "Ellipse");
addItem(RiuQwtSymbol::SYMBOL_RECT, "SYMBOL_RECT", "Rect");
addItem(RiuQwtSymbol::SYMBOL_DIAMOND, "SYMBOL_DIAMOND", "Diamond");
addItem(RiuQwtSymbol::SYMBOL_TRIANGLE, "SYMBOL_TRIANGLE", "Triangle");
addItem(RiuQwtSymbol::SYMBOL_CROSS, "SYMBOL_CROSS", "Cross");
addItem(RiuQwtSymbol::SYMBOL_XCROSS, "SYMBOL_XCROSS", "X Cross");
setDefault(RiuQwtSymbol::SYMBOL_NONE);
}
}
@@ -83,7 +84,7 @@ void RimPlotCurve::CurveInterpolation::setUp()
///
//--------------------------------------------------------------------------------------------------
RimPlotCurve::RimPlotCurve()
: m_symbolLabelPosition(RiuCurveQwtSymbol::LabelAboveSymbol)
: m_symbolLabelPosition(RiuQwtSymbol::LabelAboveSymbol)
{
CAF_PDM_InitObject("Curve", ":/WellLogCurve16x16.png", "", "");
@@ -101,12 +102,12 @@ RimPlotCurve::RimPlotCurve()
CAF_PDM_InitField(&m_curveThickness, "Thickness", 1, "Line Thickness", "", "", "");
m_curveThickness.uiCapability()->setUiEditorTypeName(caf::PdmUiComboBoxEditor::uiEditorTypeName());
caf::AppEnum< RimPlotCurve::LineStyleEnum > lineStyle = STYLE_SOLID;
caf::AppEnum< RiuQwtPlotCurve::LineStyleEnum > lineStyle = RiuQwtPlotCurve::STYLE_SOLID;
CAF_PDM_InitField(&m_lineStyle, "LineStyle", lineStyle, "Line Style", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_curveInterpolation, "CurveInterpolation", "Interpolation", "", "", "");
caf::AppEnum< RimPlotCurve::PointSymbolEnum > pointSymbol = SYMBOL_NONE;
caf::AppEnum< RiuQwtSymbol::PointSymbolEnum > pointSymbol = RiuQwtSymbol::SYMBOL_NONE;
CAF_PDM_InitField(&m_pointSymbol, "PointSymbol", pointSymbol, "Symbol", "", "", "");
CAF_PDM_InitField(&m_symbolSkipPixelDistance, "SymbolSkipPxDist", 0.0f, "Symbol Skip Distance", "", "Minimum pixel distance between symbols", "");
@@ -167,13 +168,13 @@ void RimPlotCurve::fieldChangedByUi(const caf::PdmFieldHandle* changedField, con
if (&m_pointSymbol == changedField)
{
m_symbolSize.uiCapability()->setUiReadOnly(m_pointSymbol() == RimPlotCurve::SYMBOL_NONE);
m_symbolSkipPixelDistance.uiCapability()->setUiReadOnly(m_pointSymbol() == RimPlotCurve::SYMBOL_NONE);
m_symbolSize.uiCapability()->setUiReadOnly(m_pointSymbol() == RiuQwtSymbol::SYMBOL_NONE);
m_symbolSkipPixelDistance.uiCapability()->setUiReadOnly(m_pointSymbol() == RiuQwtSymbol::SYMBOL_NONE);
}
else if (&m_lineStyle == changedField)
{
m_curveThickness.uiCapability()->setUiReadOnly(m_lineStyle() == RimPlotCurve::STYLE_NONE);
m_curveInterpolation.uiCapability()->setUiReadOnly(m_lineStyle() == RimPlotCurve::STYLE_NONE);
m_curveThickness.uiCapability()->setUiReadOnly(m_lineStyle() == RiuQwtPlotCurve::STYLE_NONE);
m_curveInterpolation.uiCapability()->setUiReadOnly(m_lineStyle() == RiuQwtPlotCurve::STYLE_NONE);
}
}
else if (changedField == &m_isUsingAutoName)
@@ -251,10 +252,10 @@ void RimPlotCurve::updateCurveVisibility(bool updateParentPlot)
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::initAfterRead()
{
m_symbolSize.uiCapability()->setUiReadOnly(m_pointSymbol() == RimPlotCurve::SYMBOL_NONE);
m_symbolSkipPixelDistance.uiCapability()->setUiReadOnly(m_pointSymbol() == RimPlotCurve::SYMBOL_NONE);
m_curveThickness.uiCapability()->setUiReadOnly(m_lineStyle() == RimPlotCurve::STYLE_NONE);
m_curveInterpolation.uiCapability()->setUiReadOnly(m_lineStyle() == RimPlotCurve::STYLE_NONE);
m_symbolSize.uiCapability()->setUiReadOnly(m_pointSymbol() == RiuQwtSymbol::SYMBOL_NONE);
m_symbolSkipPixelDistance.uiCapability()->setUiReadOnly(m_pointSymbol() == RiuQwtSymbol::SYMBOL_NONE);
m_curveThickness.uiCapability()->setUiReadOnly(m_lineStyle() == RiuQwtPlotCurve::STYLE_NONE);
m_curveInterpolation.uiCapability()->setUiReadOnly(m_lineStyle() == RiuQwtPlotCurve::STYLE_NONE);
}
//--------------------------------------------------------------------------------------------------
@@ -443,87 +444,15 @@ void RimPlotCurve::updateCurveAppearance()
QwtSymbol* symbol = nullptr;
if (m_pointSymbol() != SYMBOL_NONE)
if (m_pointSymbol() != RiuQwtSymbol::SYMBOL_NONE)
{
QwtSymbol::Style style = QwtSymbol::NoSymbol;
switch (m_pointSymbol())
{
case SYMBOL_ELLIPSE:
style = QwtSymbol::Ellipse;
break;
case SYMBOL_RECT:
style = QwtSymbol::Rect;
break;
case SYMBOL_DIAMOND:
style = QwtSymbol::Diamond;
break;
case SYMBOL_TRIANGLE:
style = QwtSymbol::Triangle;
break;
case SYMBOL_CROSS:
style = QwtSymbol::Cross;
break;
case SYMBOL_XCROSS:
style = QwtSymbol::XCross;
break;
case SYMBOL_DOWN_TRIANGLE:
style = QwtSymbol::DTriangle;
break;
default:
break;
}
// QwtPlotCurve will take ownership of the symbol
symbol = new RiuCurveQwtSymbol(style, m_symbolLabel, m_symbolLabelPosition);
symbol = new RiuQwtSymbol(m_pointSymbol(), m_symbolLabel, m_symbolLabelPosition);
symbol->setSize(m_symbolSize, m_symbolSize);
symbol->setColor(curveColor);
}
QwtPlotCurve::CurveStyle curveStyle = QwtPlotCurve::NoCurve;
Qt::PenStyle penStyle = Qt::SolidLine;
if (m_lineStyle() != STYLE_NONE)
{
switch (m_curveInterpolation())
{
case INTERPOLATION_STEP_LEFT:
curveStyle = QwtPlotCurve::Steps;
m_qwtPlotCurve->setCurveAttribute(QwtPlotCurve::Inverted, false);
break;
case INTERPOLATION_POINT_TO_POINT: // Fall through
default:
curveStyle = QwtPlotCurve::Lines;
break;
}
switch (m_lineStyle())
{
case STYLE_SOLID:
penStyle = Qt::SolidLine;
break;
case STYLE_DASH:
penStyle = Qt::DashLine;
break;
case STYLE_DOT:
penStyle = Qt::DotLine;
break;
case STYLE_DASH_DOT:
penStyle = Qt::DashDotLine;
break;
default:
break;
}
}
QPen curvePen(curveColor);
curvePen.setWidth(m_curveThickness);
curvePen.setStyle(penStyle);
m_qwtPlotCurve->setPen(curvePen);
m_qwtPlotCurve->setStyle(curveStyle);
m_qwtPlotCurve->setAppearance(m_lineStyle(), m_curveInterpolation(), m_curveThickness(), curveColor);
m_qwtPlotCurve->setSymbol(symbol);
m_qwtPlotCurve->setSymbolSkipPixelDistance(m_symbolSkipPixelDistance());
@@ -625,7 +554,7 @@ bool RimPlotCurve::yValueRange(double* minimumValue, double* maximumValue) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::setLineStyle(LineStyleEnum lineStyle)
void RimPlotCurve::setLineStyle(RiuQwtPlotCurve::LineStyleEnum lineStyle)
{
m_lineStyle = lineStyle;
}
@@ -633,7 +562,7 @@ void RimPlotCurve::setLineStyle(LineStyleEnum lineStyle)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::setSymbol(PointSymbolEnum symbolStyle)
void RimPlotCurve::setSymbol(RiuQwtSymbol::PointSymbolEnum symbolStyle)
{
m_pointSymbol = symbolStyle;
}
@@ -641,7 +570,7 @@ void RimPlotCurve::setSymbol(PointSymbolEnum symbolStyle)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPlotCurve::PointSymbolEnum RimPlotCurve::symbol()
RiuQwtSymbol::PointSymbolEnum RimPlotCurve::symbol()
{
return m_pointSymbol();
}
@@ -685,8 +614,8 @@ void RimPlotCurve::resetAppearance()
{
setColor(cvf::Color3f(cvf::Color3::BLACK));
setLineThickness(2);
setLineStyle(STYLE_SOLID);
setSymbol(SYMBOL_NONE);
setLineStyle(RiuQwtPlotCurve::STYLE_SOLID);
setSymbol(RiuQwtSymbol::SYMBOL_NONE);
setSymbolSkipDistance(10);
}

74
ApplicationCode/ProjectDataModel/RimPlotCurve.h
View File

@@ -18,7 +18,8 @@
#pragma once
#include "RifEclipseSummaryAddress.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtSymbol.h"
#include "RiuQwtPlotCurve.h"
#include "cafPdmField.h"
#include "cafPdmFieldCvfColor.h"
@@ -37,34 +38,9 @@ class RimPlotCurve : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
enum LineStyleEnum
{
STYLE_NONE,
STYLE_SOLID,
STYLE_DASH,
STYLE_DOT,
STYLE_DASH_DOT
};
enum PointSymbolEnum
{
SYMBOL_NONE,
SYMBOL_ELLIPSE,
SYMBOL_RECT,
SYMBOL_DIAMOND,
SYMBOL_TRIANGLE,
SYMBOL_CROSS,
SYMBOL_XCROSS,
SYMBOL_DOWN_TRIANGLE
};
enum CurveInterpolationEnum
{
INTERPOLATION_POINT_TO_POINT,
INTERPOLATION_STEP_LEFT,
};
typedef caf::AppEnum<CurveInterpolationEnum> CurveInterpolation;
typedef caf::AppEnum<RiuQwtPlotCurve::CurveInterpolationEnum> CurveInterpolation;
typedef caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum> LineStyle;
typedef caf::AppEnum<RiuQwtSymbol::PointSymbolEnum> PointSymbol;
public:
RimPlotCurve();
@@ -82,9 +58,9 @@ public:
void setColor(const cvf::Color3f& color);
cvf::Color3f color() const { return m_curveColor; }
void setLineStyle(LineStyleEnum lineStyle);
void setSymbol(PointSymbolEnum symbolStyle);
PointSymbolEnum symbol();
void setLineStyle(RiuQwtPlotCurve::LineStyleEnum lineStyle);
void setSymbol(RiuQwtSymbol::PointSymbolEnum symbolStyle);
RiuQwtSymbol::PointSymbolEnum symbol();
void setSymbolSkipDistance(float distance);
void setSymbolLabel(const QString& label);
void setSymbolSize(int sizeInPixels);
@@ -133,26 +109,26 @@ protected:
void curveNameUiOrdering(caf::PdmUiOrdering& uiOrdering);
protected:
QPointer<QwtPlot> m_parentQwtPlot;
RiuLineSegmentQwtPlotCurve* m_qwtPlotCurve;
QPointer<QwtPlot> m_parentQwtPlot;
RiuQwtPlotCurve* m_qwtPlotCurve;
caf::PdmField<bool> m_showCurve;
caf::PdmField<QString> m_curveName;
caf::PdmField<QString> m_customCurveName;
caf::PdmField<bool> m_showLegend;
QString m_symbolLabel;
caf::PdmField<int> m_symbolSize;
caf::PdmField<bool> m_showCurve;
caf::PdmField<QString> m_curveName;
caf::PdmField<QString> m_customCurveName;
caf::PdmField<bool> m_showLegend;
QString m_symbolLabel;
caf::PdmField<int> m_symbolSize;
caf::PdmField<bool> m_isUsingAutoName;
caf::PdmField<cvf::Color3f> m_curveColor;
caf::PdmField<int> m_curveThickness;
caf::PdmField<float> m_symbolSkipPixelDistance;
caf::PdmField<bool> m_showErrorBars;
caf::PdmField<bool> m_isUsingAutoName;
caf::PdmField<cvf::Color3f> m_curveColor;
caf::PdmField<int> m_curveThickness;
caf::PdmField<float> m_symbolSkipPixelDistance;
caf::PdmField<bool> m_showErrorBars;
caf::PdmField< caf::AppEnum< PointSymbolEnum > > m_pointSymbol;
caf::PdmField< caf::AppEnum< LineStyleEnum > > m_lineStyle;
caf::PdmField< CurveInterpolation > m_curveInterpolation;
RiuCurveQwtSymbol::LabelPosition m_symbolLabelPosition;
caf::PdmField<PointSymbol> m_pointSymbol;
caf::PdmField<LineStyle> m_lineStyle;
caf::PdmField<CurveInterpolation> m_curveInterpolation;
RiuQwtSymbol::LabelPosition m_symbolLabelPosition;
};

2
ApplicationCode/ProjectDataModel/RimWellLogCurve.cpp
View File

@@ -24,7 +24,7 @@
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuWellLogTrack.h"
#include "cafPdmUiComboBoxEditor.h"

2
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@@ -56,7 +56,7 @@
#include "RimWellPathCollection.h"
#include "RimWellPlotTools.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuWellLogTrack.h"
#include "cafPdmUiTreeOrdering.h"

2
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp
View File

@@ -33,7 +33,7 @@
#include "RimWellPlotTools.h"
#include "RimWellRftPlot.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuWellLogTrack.h"
#include "RiaApplication.h"

2
ApplicationCode/ProjectDataModel/RimWellLogRftCurve.cpp
View File

@@ -43,7 +43,7 @@
#include "RimWellPath.h"
#include "RimWellPlotTools.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuWellLogTrack.h"
#include "cafPdmObject.h"

22
ApplicationCode/ProjectDataModel/RimWellPathAttributeCurve.cpp
View File

@@ -20,7 +20,7 @@
#include "RimWellPathAttribute.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "qwt_plot.h"
@@ -44,7 +44,7 @@ RimWellPathAttributeCurve::RimWellPathAttributeCurve(RimWellPathAttribute* wellP
CAF_PDM_InitFieldNoDefault(&m_wellPathAttribute, "WellPathAttribute", "Well Attribute", "", "", "");
m_wellPathAttribute.xmlCapability()->disableIO();
m_wellPathAttribute = wellPathAttribute;
m_symbolLabelPosition = RiuCurveQwtSymbol::LabelRightOfSymbol;
m_symbolLabelPosition = RiuQwtSymbol::LabelRightOfSymbol;
}
//--------------------------------------------------------------------------------------------------
@@ -92,23 +92,27 @@ void RimWellPathAttributeCurve::onLoadDataAndUpdate(bool updateParentPlot)
{
if (m_curvePlotItem == LineCurve)
{
setLineStyle(RimPlotCurve::STYLE_SOLID);
setLineStyle(RiuQwtPlotCurve::STYLE_SOLID);
setLineThickness(4);
setSymbol(RimPlotCurve::SYMBOL_NONE);
setSymbol(RiuQwtSymbol::SYMBOL_NONE);
xValues = { radius, radius };
yValues = { 0.0, m_wellPathAttribute->depthEnd() };
}
else if (m_curvePlotItem == MarkerSymbol)
{
setLineStyle(RimPlotCurve::STYLE_NONE);
setLineThickness(0);
setSymbol(RimPlotCurve::SYMBOL_TRIANGLE);
setSymbolSize(16);
setLineStyle(RiuQwtPlotCurve::STYLE_NONE);
setLineThickness(4);
setSymbolSize(10);
if (m_curvePlotPosition == PositiveSide)
{
setSymbol(RiuQwtSymbol::SYMBOL_RIGHT_TRIANGLE);
setSymbolLabel(m_wellPathAttribute->diameterLabel());
}
else
{
setSymbol(RiuQwtSymbol::SYMBOL_LEFT_TRIANGLE);
}
xValues = { radius };
yValues = { m_wellPathAttribute->depthEnd() };
@@ -116,7 +120,7 @@ void RimWellPathAttributeCurve::onLoadDataAndUpdate(bool updateParentPlot)
}
else if (m_wellPathAttribute->type() == RimWellPathAttribute::AttributeLiner)
{
setLineStyle(RimPlotCurve::STYLE_DASH);
setLineStyle(RiuQwtPlotCurve::STYLE_DASH);
setLineThickness(2);
xValues = { radius, radius};

2
ApplicationCode/ProjectDataModel/Summary/RimAsciiDataCurve.cpp
View File

@@ -30,7 +30,7 @@
#include "RimSummaryPlot.h"
#include "RimSummaryTimeAxisProperties.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuSummaryQwtPlot.h"
#include "cafPdmUiComboBoxEditor.h"

2
ApplicationCode/ProjectDataModel/Summary/RimAsciiDataCurve.h
View File

@@ -36,7 +36,7 @@
class RifReaderEclipseSummary;
class RimSummaryCase;
class RimSummaryFilter;
class RiuLineSegmentQwtPlotCurve;
class RiuQwtPlotCurve;
class RimAsciiDataCurveAutoName;
//==================================================================================================

25
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -47,6 +47,7 @@
#include "RimSummaryFilter.h"
#include "RimSummaryPlot.h"
#include "RiuQwtPlotCurve.h"
#include "RiuPlotMainWindow.h"
#include "RiuSummaryQwtPlot.h"
#include "RiuSummaryCurveDefSelectionDialog.h"
@@ -71,8 +72,8 @@
//--------------------------------------------------------------------------------------------------
/// Internal functions
//--------------------------------------------------------------------------------------------------
RimPlotCurve::PointSymbolEnum statisticsCurveSymbolFromAddress(const RifEclipseSummaryAddress& address);
int statisticsCurveSymbolSize(RimPlotCurve::PointSymbolEnum symbol);
RiuQwtSymbol::PointSymbolEnum statisticsCurveSymbolFromAddress(const RifEclipseSummaryAddress& address);
int statisticsCurveSymbolSize(RiuQwtSymbol::PointSymbolEnum symbol);
//--------------------------------------------------------------------------------------------------
///
@@ -1027,7 +1028,7 @@ void RimEnsembleCurveSet::updateStatisticsCurves(const std::vector<RimSummaryCas
curve->setSymbolLabel(RiaStatisticsTools::replacePercentileByPValueText(
QString::fromStdString(address.ensembleStatisticsQuantityName())));
}
curve->setLineStyle(RimPlotCurve::STYLE_SOLID);
curve->setLineStyle(RiuQwtPlotCurve::STYLE_SOLID);
curve->setSummaryCaseY(m_ensembleStatCase.get());
curve->setSummaryAddressY(address);
curve->setZOrder(1000);
@@ -1274,23 +1275,23 @@ void RimEnsembleCurveSet::updateLegendMappingMode()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPlotCurve::PointSymbolEnum statisticsCurveSymbolFromAddress(const RifEclipseSummaryAddress& address)
RiuQwtSymbol::PointSymbolEnum statisticsCurveSymbolFromAddress(const RifEclipseSummaryAddress& address)
{
auto qName = QString::fromStdString(address.quantityName());
if (qName.contains(ENSEMBLE_STAT_P10_QUANTITY_NAME)) return RimPlotCurve::SYMBOL_TRIANGLE;
if (qName.contains(ENSEMBLE_STAT_P90_QUANTITY_NAME)) return RimPlotCurve::SYMBOL_DOWN_TRIANGLE;
if (qName.contains(ENSEMBLE_STAT_P50_QUANTITY_NAME)) return RimPlotCurve::SYMBOL_DIAMOND;
return RimPlotCurve::SYMBOL_ELLIPSE;
if (qName.contains(ENSEMBLE_STAT_P10_QUANTITY_NAME)) return RiuQwtSymbol::SYMBOL_TRIANGLE;
if (qName.contains(ENSEMBLE_STAT_P90_QUANTITY_NAME)) return RiuQwtSymbol::SYMBOL_DOWN_TRIANGLE;
if (qName.contains(ENSEMBLE_STAT_P50_QUANTITY_NAME)) return RiuQwtSymbol::SYMBOL_DIAMOND;
return RiuQwtSymbol::SYMBOL_ELLIPSE;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int statisticsCurveSymbolSize(RimPlotCurve::PointSymbolEnum symbol)
int statisticsCurveSymbolSize(RiuQwtSymbol::PointSymbolEnum symbol)
{
if (symbol == RimPlotCurve::SYMBOL_DIAMOND) return 8;
if (symbol == RimPlotCurve::SYMBOL_TRIANGLE) return 7;
if (symbol == RimPlotCurve::SYMBOL_DOWN_TRIANGLE) return 7;
if (symbol == RiuQwtSymbol::SYMBOL_DIAMOND) return 8;
if (symbol == RiuQwtSymbol::SYMBOL_TRIANGLE) return 7;
if (symbol == RiuQwtSymbol::SYMBOL_DOWN_TRIANGLE) return 7;
return 6;
}

2
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSetCollection.cpp
View File

@@ -32,7 +32,7 @@
#include "RimSummaryPlot.h"
#include "RimSummaryPlotSourceStepping.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuSummaryQwtPlot.h"
CAF_PDM_SOURCE_INIT(RimEnsembleCurveSetCollection, "RimEnsembleCurveSetCollection");

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryAddress.h
View File

@@ -34,7 +34,7 @@
class RifSummaryReaderInterface;
class RimSummaryCase;
class RimSummaryFilter;
class RiuLineSegmentQwtPlotCurve;
class RiuQwtPlotCurve;
class RimSummaryCurveAutoName;

20
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@@ -42,7 +42,7 @@
#include "RimSummaryTimeAxisProperties.h"
#include "RimTools.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuPlotMainWindow.h"
#include "RiuSummaryCurveDefSelectionDialog.h"
#include "RiuSummaryQwtPlot.h"
@@ -713,17 +713,17 @@ void RimSummaryCurve::forceUpdateCurveAppearanceFromCaseType()
{
if (m_yValuesSummaryCase->isObservedData())
{
setLineStyle(RimPlotCurve::STYLE_NONE);
setLineStyle(RiuQwtPlotCurve::STYLE_NONE);
if (symbol() == RimPlotCurve::SYMBOL_NONE)
if (symbol() == RiuQwtSymbol::SYMBOL_NONE)
{
setSymbol(RimPlotCurve::SYMBOL_XCROSS);
setSymbol(RiuQwtSymbol::SYMBOL_XCROSS);
}
}
else
{
setLineStyle(RimPlotCurve::STYLE_SOLID);
setSymbol(RimPlotCurve::SYMBOL_NONE);
setLineStyle(RiuQwtPlotCurve::STYLE_SOLID);
setSymbol(RiuQwtSymbol::SYMBOL_NONE);
}
}
}
@@ -779,8 +779,8 @@ void RimSummaryCurve::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
if (oldVal == nullptr && m_yValuesSummaryCase->isObservedData())
{
// If no previous case selected and observed data, use symbols to indicate observed data curve
setLineStyle(RimPlotCurve::STYLE_NONE);
setSymbol(RimPlotCurve::SYMBOL_XCROSS);
setLineStyle(RiuQwtPlotCurve::STYLE_NONE);
setSymbol(RiuQwtSymbol::SYMBOL_XCROSS);
}
plot->updateCaseNameHasChanged();
this->onLoadDataAndUpdate(true);
@@ -986,11 +986,11 @@ void RimSummaryCurve::calculateCurveInterpolationFromAddress()
auto address = m_yValuesCurveVariable()->address();
if (address.hasAccumulatedData())
{
m_curveInterpolation = INTERPOLATION_POINT_TO_POINT;
m_curveInterpolation = RiuQwtPlotCurve::INTERPOLATION_POINT_TO_POINT;
}
else
{
m_curveInterpolation = INTERPOLATION_STEP_LEFT;
m_curveInterpolation = RiuQwtPlotCurve::INTERPOLATION_STEP_LEFT;
}
}
}

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.h
View File

@@ -34,7 +34,7 @@
class RifSummaryReaderInterface;
class RimSummaryCase;
class RimSummaryFilter;
class RiuLineSegmentQwtPlotCurve;
class RiuQwtPlotCurve;
class RimSummaryCurveAutoName;
class RimSummaryAddress;

17
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.cpp
View File

@@ -20,6 +20,7 @@
#include "RiaColorTables.h"
#include "RiaSummaryCurveDefinition.h"
#include "RiuQwtPlotCurve.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCase.h"
@@ -191,11 +192,11 @@ std::map<std::string, size_t> RimSummaryCurveAppearanceCalculator::mapNameToAppe
}
else if (appearance == CurveAppearanceType::SYMBOL)
{
numOptions = caf::AppEnum<RimPlotCurve::PointSymbolEnum>::size() - 1; // -1 since the No symbol option is not counted see cycledSymbol()
numOptions = caf::AppEnum<RiuQwtSymbol::PointSymbolEnum>::size() - 1; // -1 since the No symbol option is not counted see cycledSymbol()
}
else if (appearance == CurveAppearanceType::LINE_STYLE)
{
numOptions = caf::AppEnum<RimPlotCurve::LineStyleEnum>::size() - 1; // -1 since the No symbol option is not counted see cycledLineStyle()
numOptions = caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum>::size() - 1; // -1 since the No symbol option is not counted see cycledLineStyle()
}
else {
// If none of these styles are used, fall back to a simply incrementing index
@@ -452,21 +453,21 @@ cvf::Color3f RimSummaryCurveAppearanceCalculator::cycledBrownColor(int colorInde
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPlotCurve::LineStyleEnum RimSummaryCurveAppearanceCalculator::cycledLineStyle(int index)
RiuQwtPlotCurve::LineStyleEnum RimSummaryCurveAppearanceCalculator::cycledLineStyle(int index)
{
if (index < 0) return RimPlotCurve::STYLE_SOLID;
if (index < 0) return RiuQwtPlotCurve::STYLE_SOLID;
return caf::AppEnum<RimPlotCurve::LineStyleEnum>::fromIndex(1 + (index % (caf::AppEnum<RimPlotCurve::LineStyleEnum>::size() - 1)));
return caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum>::fromIndex(1 + (index % (caf::AppEnum<RiuQwtPlotCurve::LineStyleEnum>::size() - 1)));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPlotCurve::PointSymbolEnum RimSummaryCurveAppearanceCalculator::cycledSymbol(int index)
RiuQwtSymbol::PointSymbolEnum RimSummaryCurveAppearanceCalculator::cycledSymbol(int index)
{
if (index < 0) return RimPlotCurve::SYMBOL_NONE;
if (index < 0) return RiuQwtSymbol::SYMBOL_NONE;
return caf::AppEnum<RimPlotCurve::PointSymbolEnum>::fromIndex(1 + (index % (caf::AppEnum<RimPlotCurve::PointSymbolEnum>::size() - 1)));
return caf::AppEnum<RiuQwtSymbol::PointSymbolEnum>::fromIndex(1 + (index % (caf::AppEnum<RiuQwtSymbol::PointSymbolEnum>::size() - 1)));
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.h
View File

@@ -64,7 +64,7 @@ public:
static cvf::Color3f cycledBlueColor(int colorIndex);
static cvf::Color3f cycledRedColor(int colorIndex);
static cvf::Color3f cycledBrownColor(int colorIndex);
static RimPlotCurve::PointSymbolEnum cycledSymbol(int index);
static RiuQwtSymbol::PointSymbolEnum cycledSymbol(int index);
private:
template<typename S>
@@ -74,7 +74,7 @@ private:
std::map<std::string, size_t> mapNameToAppearanceIndex(CurveAppearanceType & appearance, const std::set<std::string>& names);
RimPlotCurve::LineStyleEnum cycledLineStyle(int index);
RiuQwtPlotCurve::LineStyleEnum cycledLineStyle(int index);
int cycledLineThickness(int index);
float gradient(size_t totalCount, int index);

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveCollection.cpp
View File

@@ -29,7 +29,7 @@
#include "RimSummaryPlot.h"
#include "RimSummaryPlotSourceStepping.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuSummaryQwtPlot.h"
#include "cafPdmUiTreeViewEditor.h"

6
ApplicationCode/UserInterface/CMakeLists_files.cmake
View File

@@ -6,7 +6,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RiuDragDrop.h
${CMAKE_CURRENT_LIST_DIR}/RiuFemResultTextBuilder.h
${CMAKE_CURRENT_LIST_DIR}/RiuGeoQuestNavigation.h
${CMAKE_CURRENT_LIST_DIR}/RiuInterfaceToViewWindow.h
${CMAKE_CURRENT_LIST_DIR}/RiuLineSegmentQwtPlotCurve.h
${CMAKE_CURRENT_LIST_DIR}/RiuQwtSymbol.h
${CMAKE_CURRENT_LIST_DIR}/RiuQwtPlotCurve.h
${CMAKE_CURRENT_LIST_DIR}/RiuRimQwtPlotCurve.h
${CMAKE_CURRENT_LIST_DIR}/RiuPlotMainWindow.h
${CMAKE_CURRENT_LIST_DIR}/RiuMainWindow.h
@@ -82,7 +83,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RiuDragDrop.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuFemResultTextBuilder.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuGeoQuestNavigation.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuInterfaceToViewWindow.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuLineSegmentQwtPlotCurve.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuQwtSymbol.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuQwtPlotCurve.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuRimQwtPlotCurve.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuPlotMainWindow.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuMainWindow.cpp

12
ApplicationCode/UserInterface/RiuFlowCharacteristicsPlot.cpp
View File

@@ -22,7 +22,7 @@
#include "RimFlowCharacteristicsPlot.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuQwtPlotWheelZoomer.h"
#include "RiuQwtPlotZoomer.h"
#include "RiuResultQwtPlot.h"
@@ -151,7 +151,7 @@ void RiuFlowCharacteristicsPlot::addCurveWithLargeSymbol(QwtPlot* plot, const QS
curve->setSymbol(symbol);
// Add date and value twice to avoid a cross as symbol generated by RiuLineSegmentQwtPlotCurve
// Add date and value twice to avoid a cross as symbol generated by RiuQwtPlotCurve
std::vector<QDateTime> dateTimes;
dateTimes.push_back(dateTime);
@@ -167,9 +167,9 @@ void RiuFlowCharacteristicsPlot::addCurveWithLargeSymbol(QwtPlot* plot, const QS
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuLineSegmentQwtPlotCurve* RiuFlowCharacteristicsPlot::createEmptyCurve(QwtPlot* plot, const QString& curveName, const QColor& curveColor )
RiuQwtPlotCurve* RiuFlowCharacteristicsPlot::createEmptyCurve(QwtPlot* plot, const QString& curveName, const QColor& curveColor )
{
RiuLineSegmentQwtPlotCurve* plotCurve = new RiuLineSegmentQwtPlotCurve(curveName);
RiuQwtPlotCurve* plotCurve = new RiuQwtPlotCurve(curveName);
plotCurve->setTitle(curveName);
plotCurve->setPen(QPen(curveColor));
@@ -184,7 +184,7 @@ void RiuFlowCharacteristicsPlot::addFlowCapStorageCapCurve(const QDateTime& date
{
CVF_ASSERT(!m_dateToColorMap.empty());
RiuLineSegmentQwtPlotCurve* plotCurve = createEmptyCurve(m_flowCapVsStorageCapPlot, dateTime.toString(), m_dateToColorMap[dateTime]);
RiuQwtPlotCurve* plotCurve = createEmptyCurve(m_flowCapVsStorageCapPlot, dateTime.toString(), m_dateToColorMap[dateTime]);
plotCurve->setSamplesFromXValuesAndYValues(xVals, yVals, false);
m_flowCapVsStorageCapPlot->replot();
}
@@ -196,7 +196,7 @@ void RiuFlowCharacteristicsPlot::addSweepEfficiencyCurve(const QDateTime& dateTi
{
CVF_ASSERT(!m_dateToColorMap.empty());
RiuLineSegmentQwtPlotCurve* plotCurve = createEmptyCurve(m_sweepEffPlot, dateTime.toString(), m_dateToColorMap[dateTime]);
RiuQwtPlotCurve* plotCurve = createEmptyCurve(m_sweepEffPlot, dateTime.toString(), m_dateToColorMap[dateTime]);
plotCurve->setSamplesFromXValuesAndYValues(xVals, yVals, false);
m_sweepEffPlot->replot();

4
ApplicationCode/UserInterface/RiuFlowCharacteristicsPlot.h
View File

@@ -30,7 +30,7 @@
class RimFlowCharacteristicsPlot;
class RiuNightchartsWidget;
class RiuResultQwtPlot;
class RiuLineSegmentQwtPlotCurve;
class RiuQwtPlotCurve;
class QLabel;
@@ -63,7 +63,7 @@ public:
virtual RimViewWindow* ownerViewWindow() const override;
static void addWindowZoom(QwtPlot* plot);
static RiuLineSegmentQwtPlotCurve* createEmptyCurve(QwtPlot* plot, const QString& curveName, const QColor& curveColor);
static RiuQwtPlotCurve* createEmptyCurve(QwtPlot* plot, const QString& curveName, const QColor& curveColor);
protected:
virtual QSize sizeHint() const override;

149
ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.cpp → ApplicationCode/UserInterface/RiuQwtPlotCurve.cpp
View File

@@ -17,10 +17,12 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiaCurveDataTools.h"
#include "RiuQwtSymbol.h"
#include "qwt_symbol.h"
#include "RiaCurveDataTools.h"
#include "qwt_date.h"
#include "qwt_point_mapper.h"
#include "qwt_painter.h"
@@ -38,7 +40,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuLineSegmentQwtPlotCurve::RiuLineSegmentQwtPlotCurve(const QString &title)
RiuQwtPlotCurve::RiuQwtPlotCurve(const QString &title)
: QwtPlotCurve(title)
{
this->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
@@ -61,14 +63,14 @@ RiuLineSegmentQwtPlotCurve::RiuLineSegmentQwtPlotCurve(const QString &title)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuLineSegmentQwtPlotCurve::~RiuLineSegmentQwtPlotCurve()
RiuQwtPlotCurve::~RiuQwtPlotCurve()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vector<double>& xValues, const std::vector<double>& yValues, const std::vector<double>& yErrorValues, bool keepOnlyPositiveValues)
void RiuQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vector<double>& xValues, const std::vector<double>& yValues, const std::vector<double>& yErrorValues, bool keepOnlyPositiveValues)
{
CVF_ASSERT(xValues.size() == yValues.size());
CVF_ASSERT(yErrorValues.empty() || yErrorValues.size() == xValues.size());
@@ -115,7 +117,7 @@ void RiuLineSegmentQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vect
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vector<double>& xValues, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
void RiuQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vector<double>& xValues, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
{
setSamplesFromXValuesAndYValues(xValues, yValues, std::vector<double>(), keepOnlyPositiveValues);
}
@@ -123,31 +125,31 @@ void RiuLineSegmentQwtPlotCurve::setSamplesFromXValuesAndYValues(const std::vect
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSamplesFromDatesAndYValues(const std::vector<QDateTime>& dateTimes, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
void RiuQwtPlotCurve::setSamplesFromDatesAndYValues(const std::vector<QDateTime>& dateTimes, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
{
setSamplesFromXValuesAndYValues(RiuLineSegmentQwtPlotCurve::fromQDateTime(dateTimes), yValues, std::vector<double>(), keepOnlyPositiveValues);
setSamplesFromXValuesAndYValues(RiuQwtPlotCurve::fromQDateTime(dateTimes), yValues, std::vector<double>(), keepOnlyPositiveValues);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSamplesFromTimeTAndYValues(const std::vector<time_t>& dateTimes, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
void RiuQwtPlotCurve::setSamplesFromTimeTAndYValues(const std::vector<time_t>& dateTimes, const std::vector<double>& yValues, bool keepOnlyPositiveValues)
{
setSamplesFromXValuesAndYValues(RiuLineSegmentQwtPlotCurve::fromTime_t(dateTimes), yValues, std::vector<double>(), keepOnlyPositiveValues);
setSamplesFromXValuesAndYValues(RiuQwtPlotCurve::fromTime_t(dateTimes), yValues, std::vector<double>(), keepOnlyPositiveValues);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSamplesFromTimeTAndYValues(const std::vector<time_t>& dateTimes, const std::vector<double>& yValues, const std::vector<double>& yErrorValues, bool keepOnlyPositiveValues)
void RiuQwtPlotCurve::setSamplesFromTimeTAndYValues(const std::vector<time_t>& dateTimes, const std::vector<double>& yValues, const std::vector<double>& yErrorValues, bool keepOnlyPositiveValues)
{
setSamplesFromXValuesAndYValues(RiuLineSegmentQwtPlotCurve::fromTime_t(dateTimes), yValues, yErrorValues, keepOnlyPositiveValues);
setSamplesFromXValuesAndYValues(RiuQwtPlotCurve::fromTime_t(dateTimes), yValues, yErrorValues, keepOnlyPositiveValues);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::drawCurve(QPainter* p, int style,
void RiuQwtPlotCurve::drawCurve(QPainter* p, int style,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
const QRectF& canvasRect, int from, int to) const
{
@@ -181,7 +183,7 @@ void RiuLineSegmentQwtPlotCurve::drawCurve(QPainter* p, int style,
//--------------------------------------------------------------------------------------------------
/// Drawing symbols but skipping if they are to close to the previous one
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
void RiuQwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &canvasRect, int from, int to) const
{
@@ -237,7 +239,7 @@ void RiuLineSegmentQwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol
{
symbol.drawSymbols(painter, pointsToDisplay);
const RiuCurveQwtSymbol* sym = dynamic_cast<const RiuCurveQwtSymbol*>(&symbol);
const RiuQwtSymbol* sym = dynamic_cast<const RiuQwtSymbol*>(&symbol);
if (sym && !sym->label().isEmpty())
{
@@ -252,7 +254,7 @@ void RiuLineSegmentQwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setLineSegmentStartStopIndices(const std::vector< std::pair<size_t, size_t> >& lineSegmentStartStopIndices)
void RiuQwtPlotCurve::setLineSegmentStartStopIndices(const std::vector< std::pair<size_t, size_t> >& lineSegmentStartStopIndices)
{
m_polyLineStartStopIndices = lineSegmentStartStopIndices;
}
@@ -260,7 +262,7 @@ void RiuLineSegmentQwtPlotCurve::setLineSegmentStartStopIndices(const std::vecto
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setSymbolSkipPixelDistance(float distance)
void RiuQwtPlotCurve::setSymbolSkipPixelDistance(float distance)
{
m_symbolSkipPixelDistance = distance >= 0.0f ? distance: 0.0f;
}
@@ -268,7 +270,7 @@ void RiuLineSegmentQwtPlotCurve::setSymbolSkipPixelDistance(float distance)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::attach(QwtPlot *plot)
void RiuQwtPlotCurve::attach(QwtPlot *plot)
{
QwtPlotItem::attach(plot);
if(m_showErrorBars) m_errorBars->attach(plot);
@@ -278,7 +280,7 @@ void RiuLineSegmentQwtPlotCurve::attach(QwtPlot *plot)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::detach()
void RiuQwtPlotCurve::detach()
{
QwtPlotItem::detach();
m_errorBars->detach();
@@ -288,7 +290,7 @@ void RiuLineSegmentQwtPlotCurve::detach()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::clearErrorBars()
void RiuQwtPlotCurve::clearErrorBars()
{
m_errorBars->setSamples(nullptr);
}
@@ -296,7 +298,7 @@ void RiuLineSegmentQwtPlotCurve::clearErrorBars()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::showErrorBars(bool show)
void RiuQwtPlotCurve::showErrorBars(bool show)
{
m_showErrorBars = show;
if (m_showErrorBars && m_attachedToPlot) m_errorBars->attach(m_attachedToPlot);
@@ -306,17 +308,69 @@ void RiuLineSegmentQwtPlotCurve::showErrorBars(bool show)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuLineSegmentQwtPlotCurve::setErrorBarsColor(QColor color)
void RiuQwtPlotCurve::setErrorBarsColor(QColor color)
{
QwtIntervalSymbol* newSymbol = new QwtIntervalSymbol(QwtIntervalSymbol::Bar);
newSymbol->setPen(QPen(color));
m_errorBars->setSymbol(newSymbol);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtPlotCurve::setAppearance(LineStyleEnum lineStyle,
CurveInterpolationEnum interpolationType,
int curveThickness,
const QColor& curveColor)
{
QwtPlotCurve::CurveStyle curveStyle = QwtPlotCurve::NoCurve;
Qt::PenStyle penStyle = Qt::SolidLine;
if (lineStyle != STYLE_NONE)
{
switch (interpolationType)
{
case INTERPOLATION_STEP_LEFT:
curveStyle = QwtPlotCurve::Steps;
setCurveAttribute(QwtPlotCurve::Inverted, false);
break;
case INTERPOLATION_POINT_TO_POINT: // Fall through
default:
curveStyle = QwtPlotCurve::Lines;
break;
}
switch (lineStyle)
{
case STYLE_SOLID:
penStyle = Qt::SolidLine;
break;
case STYLE_DASH:
penStyle = Qt::DashLine;
break;
case STYLE_DOT:
penStyle = Qt::DotLine;
break;
case STYLE_DASH_DOT:
penStyle = Qt::DashDotLine;
break;
default:
break;
}
}
QPen curvePen(curveColor);
curvePen.setWidth(curveThickness);
curvePen.setStyle(penStyle);
setPen(curvePen);
setStyle(curveStyle);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RiuLineSegmentQwtPlotCurve::fromQDateTime(const std::vector<QDateTime>& dateTimes)
std::vector<double> RiuQwtPlotCurve::fromQDateTime(const std::vector<QDateTime>& dateTimes)
{
std::vector<double> doubleValues;
@@ -336,7 +390,7 @@ std::vector<double> RiuLineSegmentQwtPlotCurve::fromQDateTime(const std::vector<
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RiuLineSegmentQwtPlotCurve::fromTime_t(const std::vector<time_t>& timeSteps)
std::vector<double> RiuQwtPlotCurve::fromTime_t(const std::vector<time_t>& timeSteps)
{
std::vector<double> doubleValues;
@@ -353,50 +407,3 @@ std::vector<double> RiuLineSegmentQwtPlotCurve::fromTime_t(const std::vector<tim
return doubleValues;
}
//--------------------------------------------------------------------------------------------------
/// Internal class to support labels on symbols
//--------------------------------------------------------------------------------------------------
RiuCurveQwtSymbol::RiuCurveQwtSymbol(QwtSymbol::Style style, const QString& label, LabelPosition labelPosition)
: QwtSymbol(style), m_label(label), m_labelPosition(labelPosition)
{
}
void RiuCurveQwtSymbol::renderSymbols(QPainter *painter, const QPointF *points, int numPoints) const
{
QwtSymbol::renderSymbols(painter, points, numPoints);
if (!m_label.isEmpty())
{
for (int i = 0; i < numPoints; i++)
{
auto position = points[i];
renderSymbolLabel(painter, position);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuCurveQwtSymbol::renderSymbolLabel(QPainter *painter, const QPointF& position) const
{
int symbolWidth = this->size().width();
int labelWidth = painter->fontMetrics().width(m_label);
if (m_labelPosition == LabelAboveSymbol)
{
painter->drawText(position.x() - labelWidth / 2, position.y() - 5, m_label);
}
else if (m_labelPosition == LabelRightOfSymbol)
{
painter->drawText(position.x() + symbolWidth / 2 + 1, position.y(), m_label);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuCurveQwtSymbol::setLabelPosition(LabelPosition labelPosition)
{
m_labelPosition = labelPosition;
}

54
ApplicationCode/UserInterface/RiuLineSegmentQwtPlotCurve.h → ApplicationCode/UserInterface/RiuQwtPlotCurve.h
View File

@@ -45,11 +45,27 @@ class RiuErrorBarsQwtPlotCurve;
// Values 1.0|2.0|inf|inf|inf|1.0|2.0|1.0|inf|1.0|1.0|inf|1.0|inf
// Vec index 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13
//==================================================================================================
class RiuLineSegmentQwtPlotCurve : public QwtPlotCurve
class RiuQwtPlotCurve : public QwtPlotCurve
{
public:
explicit RiuLineSegmentQwtPlotCurve(const QString &title = QString::null);
virtual ~RiuLineSegmentQwtPlotCurve();
enum CurveInterpolationEnum
{
INTERPOLATION_POINT_TO_POINT,
INTERPOLATION_STEP_LEFT,
};
enum LineStyleEnum
{
STYLE_NONE,
STYLE_SOLID,
STYLE_DASH,
STYLE_DOT,
STYLE_DASH_DOT
};
public:
explicit RiuQwtPlotCurve(const QString &title = QString::null);
virtual ~RiuQwtPlotCurve();
void setSamplesFromXValuesAndYValues(const std::vector<double>& xValues,
const std::vector<double>& yValues,
@@ -83,6 +99,11 @@ public:
void showErrorBars(bool show);
void setErrorBarsColor(QColor color);
void setAppearance(LineStyleEnum lineStyle,
CurveInterpolationEnum interpolationType,
int curveThickness,
const QColor& curveColor);
protected:
virtual void drawCurve(QPainter* p, int style,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
@@ -108,30 +129,3 @@ private:
QwtPlotIntervalCurve* m_errorBars;
QwtPlot* m_attachedToPlot;
};
//--------------------------------------------------------------------------------------------------
/// This class overrides renderSymbols to draw symbols and labels.
/// The label is only visible in the legend, while it is clipped in the plot.
/// Therefore the method RiuLineSegmentQwtPlotCurve::drawSymbols also draw labels to have labels
/// in the plot as well.
//--------------------------------------------------------------------------------------------------
class RiuCurveQwtSymbol : public QwtSymbol
{
public:
enum LabelPosition
{
LabelAboveSymbol,
LabelRightOfSymbol
};
RiuCurveQwtSymbol(QwtSymbol::Style style, const QString& label, LabelPosition labelPosition = LabelAboveSymbol);
virtual void renderSymbols(QPainter *painter, const QPointF *points, int numPoints) const override;
void renderSymbolLabel(QPainter *painter, const QPointF& position) const;
QString label() const { return m_label; }
void setLabelPosition(LabelPosition labelPosition);
private:
QString m_label;
LabelPosition m_labelPosition;
};

127
ApplicationCode/UserInterface/RiuQwtSymbol.cpp Normal file
View File

@@ -0,0 +1,127 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015- Equinor ASA
// Copyright (C) 2015- Ceetron Solutions AS
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RiuQwtSymbol.h"
#include <QPainter>
//--------------------------------------------------------------------------------------------------
/// Internal class to support labels on symbols
//--------------------------------------------------------------------------------------------------
RiuQwtSymbol::RiuQwtSymbol(PointSymbolEnum riuStyle, const QString& label, LabelPosition labelPosition)
: QwtSymbol(QwtSymbol::NoSymbol), m_label(label), m_labelPosition(labelPosition)
{
QwtSymbol::Style style = QwtSymbol::NoSymbol;
switch (riuStyle)
{
case SYMBOL_ELLIPSE:
style = QwtSymbol::Ellipse;
break;
case SYMBOL_RECT:
style = QwtSymbol::Rect;
break;
case SYMBOL_DIAMOND:
style = QwtSymbol::Diamond;
break;
case SYMBOL_TRIANGLE:
style = QwtSymbol::Triangle;
break;
case SYMBOL_CROSS:
style = QwtSymbol::Cross;
break;
case SYMBOL_XCROSS:
style = QwtSymbol::XCross;
break;
case SYMBOL_DOWN_TRIANGLE:
style = QwtSymbol::DTriangle;
break;
case SYMBOL_LEFT_TRIANGLE:
style = QwtSymbol::Path;
{
QPainterPath path;
path.moveTo(0, 0);
path.lineTo(-10, 0);
path.lineTo(0, -10);
path.lineTo(0, 0);
setPath(path);
setPinPoint(QPointF(0, 0));
}
break;
case SYMBOL_RIGHT_TRIANGLE:
style = QwtSymbol::Path;
{
QPainterPath path;
path.moveTo(0, 0);
path.lineTo(10, 0);
path.lineTo(0, -10);
path.lineTo(0, 0);
setPath(path);
setPinPoint(QPointF(0, 0));
}
break;
default:
break;
}
setStyle(style);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtSymbol::renderSymbols(QPainter *painter, const QPointF *points, int numPoints) const
{
QwtSymbol::renderSymbols(painter, points, numPoints);
if (!m_label.isEmpty())
{
for (int i = 0; i < numPoints; i++)
{
auto position = points[i];
renderSymbolLabel(painter, position);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtSymbol::renderSymbolLabel(QPainter *painter, const QPointF& position) const
{
int symbolWidth = this->size().width();
int labelWidth = painter->fontMetrics().width(m_label);
if (m_labelPosition == LabelAboveSymbol)
{
painter->drawText(position.x() - labelWidth / 2, position.y() - 5, m_label);
}
else if (m_labelPosition == LabelRightOfSymbol)
{
painter->drawText(position.x() + symbolWidth / 2 + 1, position.y(), m_label);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuQwtSymbol::setLabelPosition(LabelPosition labelPosition)
{
m_labelPosition = labelPosition;
}

66
ApplicationCode/UserInterface/RiuQwtSymbol.h Normal file
View File

@@ -0,0 +1,66 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015- Equinor ASA
// Copyright (C) 2015- Ceetron Solutions AS
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "qwt_symbol.h"
#include <QString>
//--------------------------------------------------------------------------------------------------
/// This class overrides renderSymbols to draw symbols and labels.
/// The label is only visible in the legend, while it is clipped in the plot.
/// Therefore the method RiuQwtPlotCurve::drawSymbols also draw labels to have labels
/// in the plot as well.
//--------------------------------------------------------------------------------------------------
class RiuQwtSymbol : public QwtSymbol
{
public:
enum LabelPosition
{
LabelAboveSymbol,
LabelRightOfSymbol
};
enum PointSymbolEnum
{
SYMBOL_NONE,
SYMBOL_ELLIPSE,
SYMBOL_RECT,
SYMBOL_DIAMOND,
SYMBOL_TRIANGLE,
SYMBOL_CROSS,
SYMBOL_XCROSS,
SYMBOL_DOWN_TRIANGLE,
SYMBOL_LEFT_TRIANGLE,
SYMBOL_RIGHT_TRIANGLE
};
RiuQwtSymbol(PointSymbolEnum riuStyle, const QString& label, LabelPosition labelPosition = LabelAboveSymbol);
virtual void renderSymbols(QPainter *painter, const QPointF *points, int numPoints) const override;
void renderSymbolLabel(QPainter *painter, const QPointF& position) const;
QString label() const { return m_label; }
void setLabelPosition(LabelPosition labelPosition);
private:
QString m_label;
LabelPosition m_labelPosition;
};

4
ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp
View File

@@ -19,7 +19,7 @@
#include "RiuRelativePermeabilityPlotPanel.h"
#include "RiuRelativePermeabilityPlotUpdater.h"
#include "RiuSummaryQwtPlot.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuTextDialog.h"
#include "RiaCurveDataTools.h"
@@ -315,7 +315,7 @@ void RiuRelativePermeabilityPlotPanel::plotCurvesInQwt(RiaEclipseUnitTools::Unit
}
//QwtPlotCurve* qwtCurve = new QwtPlotCurve(curve.name.c_str());
RiuLineSegmentQwtPlotCurve* qwtCurve = new RiuLineSegmentQwtPlotCurve(curve.name.c_str());
RiuQwtPlotCurve* qwtCurve = new RiuQwtPlotCurve(curve.name.c_str());
CVF_ASSERT(curve.saturationVals.size() == curve.yVals.size());
//qwtCurve->setSamples(curve.xVals.data(), curve.yVals.data(), static_cast<int>(curve.xVals.size()));

4
ApplicationCode/UserInterface/RiuResultQwtPlot.cpp
View File

@@ -24,7 +24,7 @@
#include "RimContextCommandBuilder.h"
#include "RimCase.h"
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "RiuSummaryQwtPlot.h"
#include "RiuTextDialog.h"
@@ -72,7 +72,7 @@ void RiuResultQwtPlot::addCurve(const RimCase* rimCase, const QString& curveName
return;
}
RiuLineSegmentQwtPlotCurve* plotCurve = new RiuLineSegmentQwtPlotCurve("Curve 1");
RiuQwtPlotCurve* plotCurve = new RiuQwtPlotCurve("Curve 1");
plotCurve->setSamplesFromDatesAndYValues(dateTimes, timeHistoryValues, false);
plotCurve->setTitle(curveName);

2
ApplicationCode/UserInterface/RiuRimQwtPlotCurve.cpp
View File

@@ -23,7 +23,7 @@
///
//--------------------------------------------------------------------------------------------------
RiuRimQwtPlotCurve::RiuRimQwtPlotCurve(RimPlotCurve* ownerRimCurve, const QString &title /*= QString::null*/)
: RiuLineSegmentQwtPlotCurve(title)
: RiuQwtPlotCurve(title)
, m_ownerRimCurve(ownerRimCurve)
{

4
ApplicationCode/UserInterface/RiuRimQwtPlotCurve.h
View File

@@ -17,13 +17,13 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiuLineSegmentQwtPlotCurve.h"
#include "RiuQwtPlotCurve.h"
#include "cafPdmPointer.h"
class RimPlotCurve;
class RiuRimQwtPlotCurve: public RiuLineSegmentQwtPlotCurve
class RiuRimQwtPlotCurve: public RiuQwtPlotCurve
{
public:
explicit RiuRimQwtPlotCurve(RimPlotCurve* ownerRimCurve, const QString &title = QString::null);