CDPP / AMDA_Kernel

Commit b92d25564e2311f7dcb2240464b5130f1712ed5c

Authored by Hacene SI HADJ MOHAND
2 parents 2d64c235 5e31eec0
Exists in master and in 79 other branches 10038, 10098, 5390, 5770, 6728, 7616, 7811, 7875, 8045_8044, 8295, 8459, 8528, 8928, 9016, 9016Bis, 9017, 9017-new, 9049, 9084, 9259, 9326, 9347, 9383, 9719, 9719.new, AllLegends, CDF_ISTP, CDF_ISTP_HOPEFULLY_ALL_WORKING, FER_10400, FER_10412, FER_10663, FER_10765, FER_11000, FER_11100, FER_11242, FER_11277, FER_11500, FER_11537, FER_11588, FER_11651, FER_19836, FER_5344, FER_6031, FER_6598, FER_6966, FER_7318, FER_7618, FER_7857, FER_8455, FER_9629, FER_CR41, FER_CR42, FER_CR43, FER_TFCat, Histo1D2D, JUNO_JEDI, MAZ_10936, MAZ_6018, MAZ_9016_New, MAZ_FIX_9016, SpeasyGet, amdadev, amdadev_test, cu2022, das2, density_maps, develop, evol_9042, feature/9259, frames-transformation, pickle, rm_6912, rm_7926, rm_8050, rm_8932, shue, shue97, test-merge, ubuntu

Merge branch '7359'

Showing 2 changed files with 477 additions and 440 deletions   Show diff stats
Inline Side-by-side
src/ParamOutputImpl/Plot/AxisLegendManager.cc
  Diff comments   View file @b92d255
1 #include "AxisLegendManager.hh" 1 #include "AxisLegendManager.hh"
  2 +#include <iostream> // std::cout
  3 +#include <string>
  4 +#include <vector>
2 5
3 using namespace AMDA::Info; 6 using namespace AMDA::Info;
4 7
5 -namespace plot  
6 -{ 8 +namespace plot {
7 9
8 -void AxisLegendManager::configureXAxisLegendForSeries(  
9 - XYPlot* plot)  
10 -{  
11 - // Build list of all indexes used by each parameters for each x axes  
12 - std::map<std::string, AxisParamsComponents> axesParamsComponents; 10 + void AxisLegendManager::configureXAxisLegendForSeries(
  11 + XYPlot* plot) {
  12 + // Build list of all indexes used by each parameters for each x axes
  13 + std::map<std::string, AxisParamsComponents> axesParamsComponents;
13 14
14 - // Compute nb series to draw by y axis  
15 - std::map<std::string,int> nbSeriesByYAxisMap = plot->getNbSeriesByYAxis(); 15 + // Compute nb series to draw by y axis
  16 + std::map<std::string, int> nbSeriesByYAxisMap = plot->getNbSeriesByYAxis();
16 17
17 - SeriesProperties lSeriesProperties;  
18 - for (auto param: plot->_parameterAxesList) {  
19 - for(auto lSeriesProperties : param.getYSeriePropertiesList()) {  
20 - if(!lSeriesProperties.hasYAxis() || !lSeriesProperties.hasXAxis())  
21 - continue; 18 + SeriesProperties lSeriesProperties;
  19 + for (auto param : plot->_parameterAxesList) {
  20 + for (auto lSeriesProperties : param.getYSeriePropertiesList()) {
  21 + if (!lSeriesProperties.hasYAxis() || !lSeriesProperties.hasXAxis())
  22 + continue;
22 23
23 - bool moreThanOneSerieForAxis = (nbSeriesByYAxisMap[lSeriesProperties.getYAxisId()] > 1); 24 + bool moreThanOneSerieForAxis = (nbSeriesByYAxisMap[lSeriesProperties.getYAxisId()] > 1);
24 25
25 - ParameterAxes* xParameter = plot->getParameterAxesByXSerieId(lSeriesProperties.getXId()); 26 + ParameterAxes* xParameter = plot->getParameterAxesByXSerieId(lSeriesProperties.getXId());
26 27
27 - XSeriesProperties xSerie = xParameter->getXSeriePropertiesById(lSeriesProperties.getXId()); 28 + XSeriesProperties xSerie = xParameter->getXSeriePropertiesById(lSeriesProperties.getXId());
28 29
29 - std::string xAxisId = lSeriesProperties.getXAxisId(); 30 + std::string xAxisId = lSeriesProperties.getXAxisId();
30 31
31 - boost::shared_ptr<Axis> lXAxis = plot->_panel->getAxis(xAxisId);  
32 - if (lXAxis.get() == nullptr) {  
33 - continue;  
34 - } 32 + boost::shared_ptr<Axis> lXAxis = plot->_panel->getAxis(xAxisId);
  33 + if (lXAxis.get() == nullptr) {
  34 + continue;
  35 + }
  36 +
  37 + Color compLegendColor = lXAxis->_color;
  38 + if (moreThanOneSerieForAxis && (lSeriesProperties.getColorSerieId() == -1) && (!plot->_panel->_page->_superposeMode)) {
  39 + compLegendColor = plot->getSerieLineColor(lSeriesProperties, moreThanOneSerieForAxis);
  40 + }
  41 +
  42 + ParameterIndexComponentColor xIndex = ParameterIndexComponentColor(xSerie.getIndex(), compLegendColor);
  43 + pushComponentInList(xSerie.getParamId(), xIndex, axesParamsComponents[xAxisId]);
  44 + }
  45 + }
  46 +
  47 + if (!plot->_panel->_page->_superposeMode) {
  48 + plot->resetAutomaticSerieColorCursor();
  49 + }
  50 +
  51 + std::list<std::string> legendLines;
  52 + for (auto axisParamsComponents : axesParamsComponents) {
  53 + boost::shared_ptr<Axis> lXAxis = plot->_panel->getAxis(axisParamsComponents.first);
  54 + setAxisLegendForSeries(plot, lXAxis, axisParamsComponents.second);
  55 + }
  56 + }
  57 +
  58 + void AxisLegendManager::configureYAxisLegendForSpectro(
  59 + PanelPlotOutput* plot) {
  60 + for (auto param : plot->_parameterAxesList) {
  61 + std::shared_ptr<SpectroProperties> spectroPropertiesPtr = param.getSpectroProperties();
  62 + if (spectroPropertiesPtr == nullptr)
  63 + continue; //no spectro defined
  64 +
  65 + if (!spectroPropertiesPtr->hasYAxis())
  66 + continue;
  67 +
  68 + std::string yAxisId = spectroPropertiesPtr->getYAxisId();
  69 + boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(yAxisId);
  70 + if (lYAxis.get() == nullptr)
  71 + continue;
  72 +
  73 + if (!lYAxis->_legend.isEmpty())
  74 + continue;
  75 +
  76 + setAxisLegendForTable(plot, lYAxis, param._originalParamId, spectroPropertiesPtr->getParamId(), spectroPropertiesPtr->getIndexes(), spectroPropertiesPtr->getRelatedDim());
  77 + return;
  78 + }
  79 + }
  80 +
  81 + void AxisLegendManager::configureYAxisLegendForSeries(
  82 + PanelPlotOutput* plot) {
  83 + SeriesProperties lSeriesProperties;
  84 +
  85 + // Compute nb series to draw by y axis
  86 + std::map<std::string, int> nbSeriesByYAxisMap = plot->getNbSeriesByYAxis();
  87 +
  88 + // Build list of all indexes used by each parameters for each y axes
  89 + std::map<std::string, AxisParamsComponents> axesParamsComponents;
  90 + if (!plot->_panel->_page->_superposeMode) {
  91 + plot->resetAutomaticSerieColorCursor();
  92 + }
  93 + for (auto param : plot->_parameterAxesList) {
  94 + for (auto lSeriesProperties : param.getYSeriePropertiesList()) {
  95 + if (!lSeriesProperties.hasYAxis())
  96 + continue;
  97 +
  98 + bool moreThanOneSerieForAxis = (nbSeriesByYAxisMap[lSeriesProperties.getYAxisId()] > 1);
  99 +
  100 + std::string yAxisId = lSeriesProperties.getYAxisId();
  101 + boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(yAxisId);
  102 + if (lYAxis.get() == nullptr) {
  103 + continue;
  104 + }
  105 +
  106 + for (auto index : lSeriesProperties.getIndexList(plot->_pParameterValues)) {
  107 + Color compLegendColor = lYAxis->_color;
  108 + if (moreThanOneSerieForAxis && (lSeriesProperties.getColorSerieId() == -1) && (!plot->_panel->_page->_superposeMode)) {
  109 + compLegendColor = plot->getSerieLineColor(lSeriesProperties, moreThanOneSerieForAxis);
  110 + }
  111 + ParameterIndexComponentColor yIndex = ParameterIndexComponentColor(index, compLegendColor);
  112 + pushComponentInList(lSeriesProperties.getParamId(), yIndex, axesParamsComponents[yAxisId]);
  113 + }
  114 + }
  115 + }
  116 + if (!plot->_panel->_page->_superposeMode) {
  117 + plot->resetAutomaticSerieColorCursor();
  118 + }
  119 +
  120 + std::list<std::string> legendLines;
  121 + for (auto axisParamsComponents : axesParamsComponents) {
  122 + boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(axisParamsComponents.first);
  123 + setAxisLegendForSeries(plot, lYAxis, axisParamsComponents.second);
  124 + }
  125 + }
  126 +
  127 + void AxisLegendManager::configureColorAxisLegendForSeries(
  128 + PanelPlotOutput* plot) {
  129 + SeriesProperties lSeriesProperties;
  130 + ColorSeriesProperties lColorSerieProperties;
  131 + boost::shared_ptr<Axis> lZAxis = plot->_panel->getColorAxis();
  132 +
  133 + if (lZAxis.get() == nullptr) {
  134 + return;
  135 + }
  136 +
  137 + // Build list of all indexes used by each parameters for each y axes
  138 + AxisParamsComponents axisParamsComponents;
  139 + for (auto param : plot->_parameterAxesList) {
  140 + for (auto lSeriesProperties : param.getYSeriePropertiesList()) {
  141 + if (!lSeriesProperties.hasYAxis())
  142 + continue;
  143 +
  144 + std::string yParamId = lSeriesProperties.getParamId();
  145 +
  146 + //check if a colored param is defined for this serie
  147 + if (lSeriesProperties.getColorParamId().empty())
  148 + continue;
  149 +
  150 + ParameterAxes* colorSerieParameterAxes = plot->getParameterAxesByColorSerieId(lSeriesProperties.getColorSerieId());
  151 +
  152 + if (colorSerieParameterAxes == NULL)
  153 + continue;
  154 +
  155 + lColorSerieProperties = colorSerieParameterAxes->getColorSeriePropertiesById(lSeriesProperties.getColorSerieId());
  156 +
  157 + ParameterIndexComponentColor colorSerieIndex = ParameterIndexComponentColor(-1, -1, lZAxis->_color);
  158 + if (lColorSerieProperties.getIndex() > -1)
  159 + colorSerieIndex = ParameterIndexComponentColor(lColorSerieProperties.getIndex(), -1, lZAxis->_color);
  160 + pushComponentInList(lColorSerieProperties.getColorParamIds()[yParamId], colorSerieIndex, axisParamsComponents);
  161 + }
  162 + }
  163 +
  164 + setAxisLegendForSeries(plot, lZAxis, axisParamsComponents);
  165 + }
  166 +
  167 + void AxisLegendManager::configureColorAxisLegendForSpectro(
  168 + PanelPlotOutput* plot) {
  169 + boost::shared_ptr<Axis> lZAxis = plot->_panel->getColorAxis();
  170 +
  171 + if (lZAxis.get() == nullptr) {
  172 + return;
  173 + }
35 174
36 - Color compLegendColor = lXAxis->_color;  
37 - if (moreThanOneSerieForAxis && (lSeriesProperties.getColorSerieId() == -1) && (!plot->_panel->_page->_superposeMode)) {  
38 - compLegendColor = plot->getSerieLineColor(lSeriesProperties, moreThanOneSerieForAxis);  
39 - } 175 + for (auto param : plot->_parameterAxesList) {
  176 + std::shared_ptr<SpectroProperties> spectroPropertiesPtr = param.getSpectroProperties();
  177 + if (spectroPropertiesPtr == nullptr)
  178 + continue; //no spectro defined
40 179
41 - ParameterIndexComponentColor xIndex = ParameterIndexComponentColor(xSerie.getIndex(), compLegendColor);  
42 - pushComponentInList(xSerie.getParamId(), xIndex, axesParamsComponents[xAxisId]);  
43 - }  
44 - } 180 + if (!spectroPropertiesPtr->hasZAxis())
  181 + continue;
45 182
46 - if (!plot->_panel->_page->_superposeMode) {  
47 - plot->resetAutomaticSerieColorCursor();  
48 - } 183 + setAxisLegendForSpectro(plot, lZAxis, param._originalParamId);
  184 + break;
  185 + }
  186 + }
  187 +
  188 + void AxisLegendManager::pushComponentInList(std::string paramId, ParameterIndexComponentColor& index, AxisParamsComponents& axisParamsComponents) {
  189 + if (index.getDim1Index() == -1 && index.getDim2Index() == -1) {
  190 + //All indexes of this parameter are used
  191 + axisParamsComponents[paramId].clear();
  192 + axisParamsComponents[paramId].push_back(index);
  193 + } else {
  194 + if (axisParamsComponents[paramId].size() > 0) {
  195 + if (axisParamsComponents[paramId].front().getDim1Index() == -1 && axisParamsComponents[paramId].front().getDim2Index() == -1) {
  196 + //Skip. All components already defined for this paramter on this axis
  197 + return;
  198 + }
  199 + }
  200 + for (auto crtIndex : axisParamsComponents[paramId]) {
  201 + if ((crtIndex.getDim1Index() == index.getDim1Index()) && (crtIndex.getDim2Index() == index.getDim2Index())) {
  202 + //Component already exists
  203 + return;
  204 + }
  205 + }
  206 + //Add this components for this axis
  207 + axisParamsComponents[paramId].push_back(index);
  208 + }
  209 +
  210 + }
  211 +
  212 + void AxisLegendManager::setAxisLegendForSeries(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, AxisParamsComponents& axisParamsComponents) {
  213 + if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {
  214 + return;
  215 + }
  216 +
  217 + // Retrieve ParamInfo Manager
  218 + ParamMgr* piMgr = ParamMgr::getInstance();
  219 +
  220 + for (auto paramsComponents : axisParamsComponents) {
  221 + ParameterSPtr p = plot->_parameterManager.getParameter(paramsComponents.first);
  222 + ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());
  223 + if (paramsComponents.second.size() == p->getDataWriterTemplate()->getParamData()->getDim1() * p->getDataWriterTemplate()->getParamData()->getDim2()) {
  224 + //All components of this parameter are used by this axis => merge
  225 + Color color = paramsComponents.second.front().getColor();
  226 + paramsComponents.second.clear();
  227 + paramsComponents.second.push_back(ParameterIndexComponentColor(-1, -1, color));
  228 + }
  229 + bool isFirstComponent = true;
  230 + for (auto components : paramsComponents.second) {
  231 + if (paramInfo == nullptr)
  232 + continue;
  233 + Label label(pAxis->_legend.getFont(), components.getColor());
  234 + if (axisParamsComponents.size() == 1) {
  235 + if (isFirstComponent) {
  236 + std::string info = getMissionInstrumentInfo(paramInfo);
  237 + if (!info.empty()) {
  238 + label._text = info;
  239 + addBreakLine(label._text);
  240 + }
  241 + }
  242 + } else {
  243 + std::string info = getMissionInfo(paramInfo);
  244 + if (!info.empty()) {
  245 + label._text = info + ", ";
  246 + }
  247 + }
  248 + label._text += getParamLegend(paramInfo, components);
  249 + pAxis->_legend.pushLabel(label);
  250 + isFirstComponent = false;
  251 + }
  252 + }
  253 + }
  254 +
  255 + void AxisLegendManager::setAxisLegendForSpectro(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, std::string originalParamId) {
  256 + if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {
  257 + return;
  258 + }
  259 +
  260 + // Retrieve ParamInfo Manager
  261 + ParamMgr* piMgr = ParamMgr::getInstance();
  262 +
  263 + ParameterSPtr p = plot->_parameterManager.getParameter(originalParamId);
  264 + AMDA::Info::ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());
  265 + if (paramInfo == nullptr)
  266 + return;
49 267
50 - std::list<std::string> legendLines;  
51 - for (auto axisParamsComponents : axesParamsComponents) {  
52 - boost::shared_ptr<Axis> lXAxis = plot->_panel->getAxis(axisParamsComponents.first);  
53 - setAxisLegendForSeries(plot, lXAxis, axisParamsComponents.second); 268 + Label label(pAxis->_legend.getFont(), pAxis->_legend.getColor());
  269 + addInfoPart(label._text, paramInfo->getShortName());
  270 + addInfoPart(label._text, getTransformedUnits(paramInfo->getUnits()));
  271 + pAxis->_legend.setLabel(label);
  272 + }
  273 +
  274 + void AxisLegendManager::setAxisLegendForTable(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, std::string originalParamId, std::string paramId, AMDA::Common::ParameterIndexComponentList& indexes, int relatedDim) {
  275 + if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {
  276 + return;
54 } 277 }
55 -}  
56 -  
57 -void AxisLegendManager::configureYAxisLegendForSpectro(  
58 - PanelPlotOutput* plot)  
59 -{  
60 - for (auto param: plot->_parameterAxesList) {  
61 - std::shared_ptr<SpectroProperties> spectroPropertiesPtr = param.getSpectroProperties();  
62 - if (spectroPropertiesPtr == nullptr)  
63 - continue; //no spectro defined  
64 -  
65 - if(!spectroPropertiesPtr->hasYAxis())  
66 - continue;  
67 -  
68 - std::string yAxisId = spectroPropertiesPtr->getYAxisId();  
69 - boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(yAxisId);  
70 - if (lYAxis.get() == nullptr)  
71 - continue;  
72 -  
73 - if (!lYAxis->_legend.isEmpty())  
74 - continue;  
75 -  
76 - setAxisLegendForTable(plot, lYAxis, param._originalParamId, spectroPropertiesPtr->getParamId(), spectroPropertiesPtr->getIndexes(), spectroPropertiesPtr->getRelatedDim());  
77 - return;  
78 - }  
79 -}  
80 -  
81 -void AxisLegendManager::configureYAxisLegendForSeries(  
82 - PanelPlotOutput* plot)  
83 -{  
84 - SeriesProperties lSeriesProperties;  
85 -  
86 - // Compute nb series to draw by y axis  
87 - std::map<std::string,int> nbSeriesByYAxisMap = plot->getNbSeriesByYAxis();  
88 -  
89 - // Build list of all indexes used by each parameters for each y axes  
90 - std::map<std::string, AxisParamsComponents> axesParamsComponents;  
91 - if (!plot->_panel->_page->_superposeMode) {  
92 - plot->resetAutomaticSerieColorCursor();  
93 - }  
94 - for (auto param: plot->_parameterAxesList)  
95 - {  
96 - for(auto lSeriesProperties : param.getYSeriePropertiesList()) {  
97 - if(!lSeriesProperties.hasYAxis())  
98 - continue;  
99 -  
100 - bool moreThanOneSerieForAxis = (nbSeriesByYAxisMap[lSeriesProperties.getYAxisId()] > 1);  
101 -  
102 - std::string yAxisId = lSeriesProperties.getYAxisId();  
103 - boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(yAxisId);  
104 - if (lYAxis.get() == nullptr) {  
105 - continue;  
106 - }  
107 -  
108 - for (auto index : lSeriesProperties.getIndexList(plot->_pParameterValues)) {  
109 - Color compLegendColor = lYAxis->_color;  
110 - if (moreThanOneSerieForAxis && (lSeriesProperties.getColorSerieId() == -1) && (!plot->_panel->_page->_superposeMode)) {  
111 - compLegendColor = plot->getSerieLineColor(lSeriesProperties, moreThanOneSerieForAxis);  
112 - }  
113 - ParameterIndexComponentColor yIndex = ParameterIndexComponentColor(index, compLegendColor);  
114 - pushComponentInList(lSeriesProperties.getParamId(), yIndex, axesParamsComponents[yAxisId]);  
115 - }  
116 - }  
117 - }  
118 - if (!plot->_panel->_page->_superposeMode) {  
119 - plot->resetAutomaticSerieColorCursor();  
120 - }  
121 -  
122 - std::list<std::string> legendLines;  
123 - for (auto axisParamsComponents : axesParamsComponents) {  
124 - boost::shared_ptr<Axis> lYAxis = plot->_panel->getAxis(axisParamsComponents.first);  
125 - setAxisLegendForSeries(plot, lYAxis, axisParamsComponents.second);  
126 - }  
127 -}  
128 -  
129 -void AxisLegendManager::configureColorAxisLegendForSeries(  
130 - PanelPlotOutput* plot)  
131 -{  
132 - SeriesProperties lSeriesProperties;  
133 - ColorSeriesProperties lColorSerieProperties;  
134 - boost::shared_ptr<Axis> lZAxis = plot->_panel->getColorAxis();  
135 -  
136 - if (lZAxis.get() == nullptr) {  
137 - return;  
138 - }  
139 -  
140 - // Build list of all indexes used by each parameters for each y axes  
141 - AxisParamsComponents axisParamsComponents;  
142 - for (auto param: plot->_parameterAxesList) {  
143 - for(auto lSeriesProperties : param.getYSeriePropertiesList()) {  
144 - if(!lSeriesProperties.hasYAxis())  
145 - continue;  
146 -  
147 - std::string yParamId = lSeriesProperties.getParamId();  
148 -  
149 - //check if a colored param is defined for this serie  
150 - if(lSeriesProperties.getColorParamId().empty())  
151 - continue;  
152 -  
153 - ParameterAxes* colorSerieParameterAxes = plot->getParameterAxesByColorSerieId(lSeriesProperties.getColorSerieId());  
154 -  
155 - if (colorSerieParameterAxes == NULL)  
156 - continue;  
157 -  
158 - lColorSerieProperties = colorSerieParameterAxes->getColorSeriePropertiesById(lSeriesProperties.getColorSerieId());  
159 -  
160 - ParameterIndexComponentColor colorSerieIndex = ParameterIndexComponentColor(-1, -1, lZAxis->_color);  
161 - if (lColorSerieProperties.getIndex() > -1)  
162 - colorSerieIndex = ParameterIndexComponentColor(lColorSerieProperties.getIndex(), -1, lZAxis->_color);  
163 - pushComponentInList(lColorSerieProperties.getColorParamIds()[yParamId], colorSerieIndex, axisParamsComponents);  
164 - }  
165 - }  
166 -  
167 - setAxisLegendForSeries(plot, lZAxis, axisParamsComponents);  
168 -}  
169 -  
170 -void AxisLegendManager::configureColorAxisLegendForSpectro(  
171 - PanelPlotOutput* plot)  
172 -{  
173 - boost::shared_ptr<Axis> lZAxis = plot->_panel->getColorAxis();  
174 -  
175 - if (lZAxis.get() == nullptr) {  
176 - return;  
177 - }  
178 -  
179 - for (auto param: plot->_parameterAxesList) {  
180 - std::shared_ptr<SpectroProperties> spectroPropertiesPtr = param.getSpectroProperties();  
181 - if (spectroPropertiesPtr == nullptr)  
182 - continue; //no spectro defined  
183 -  
184 - if(!spectroPropertiesPtr->hasZAxis())  
185 - continue;  
186 -  
187 - setAxisLegendForSpectro(plot, lZAxis, param._originalParamId);  
188 - break;  
189 - }  
190 -}  
191 -  
192 -void AxisLegendManager::pushComponentInList(std::string paramId, ParameterIndexComponentColor& index, AxisParamsComponents& axisParamsComponents) {  
193 - if (index.getDim1Index() == -1 && index.getDim2Index() == -1) {  
194 - //All indexes of this parameter are used  
195 - axisParamsComponents[paramId].clear();  
196 - axisParamsComponents[paramId].push_back(index);  
197 - }  
198 - else {  
199 - if (axisParamsComponents[paramId].size() > 0) {  
200 - if (axisParamsComponents[paramId].front().getDim1Index() == -1 && axisParamsComponents[paramId].front().getDim2Index() == -1) {  
201 - //Skip. All components already defined for this paramter on this axis  
202 - return;  
203 - }  
204 - }  
205 - for (auto crtIndex : axisParamsComponents[paramId]) {  
206 - if ((crtIndex.getDim1Index() == index.getDim1Index()) && (crtIndex.getDim2Index() == index.getDim2Index())) {  
207 - //Component already exists  
208 - return;  
209 - }  
210 - }  
211 - //Add this components for this axis  
212 - axisParamsComponents[paramId].push_back(index);  
213 - }  
214 -  
215 -}  
216 -  
217 -void AxisLegendManager::setAxisLegendForSeries(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, AxisParamsComponents& axisParamsComponents) {  
218 - if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {  
219 - return;  
220 - }  
221 -  
222 - // Retrieve ParamInfo Manager  
223 - ParamMgr* piMgr = ParamMgr::getInstance();  
224 -  
225 - for (auto paramsComponents : axisParamsComponents) {  
226 - ParameterSPtr p = plot->_parameterManager.getParameter(paramsComponents.first);  
227 - ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());  
228 - if (paramsComponents.second.size() == p->getDataWriterTemplate()->getParamData()->getDim1() * p->getDataWriterTemplate()->getParamData()->getDim2()) {  
229 - //All components of this parameter are used by this axis => merge  
230 - Color color = paramsComponents.second.front().getColor();  
231 - paramsComponents.second.clear();  
232 - paramsComponents.second.push_back(ParameterIndexComponentColor(-1,-1, color));  
233 - }  
234 - bool isFirstComponent = true;  
235 - for (auto components : paramsComponents.second) {  
236 - if (paramInfo == nullptr)  
237 - continue;  
238 - Label label(pAxis->_legend.getFont(), components.getColor());  
239 - if (axisParamsComponents.size() == 1) {  
240 - if (isFirstComponent) {  
241 - std::string info = getMissionInstrumentInfo(paramInfo);  
242 - if (!info.empty()) {  
243 - label._text = info;  
244 - addBreakLine(label._text);  
245 - }  
246 - }  
247 - }  
248 - else {  
249 - std::string info = getMissionInfo(paramInfo);  
250 - if (!info.empty()) {  
251 - label._text = info + ", ";  
252 - }  
253 - }  
254 - label._text += getParamLegend(paramInfo, components);  
255 - pAxis->_legend.pushLabel(label);  
256 - isFirstComponent = false;  
257 - }  
258 - }  
259 -}  
260 -  
261 -void AxisLegendManager::setAxisLegendForSpectro(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, std::string originalParamId) {  
262 - if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {  
263 - return;  
264 - }  
265 -  
266 - // Retrieve ParamInfo Manager  
267 - ParamMgr* piMgr = ParamMgr::getInstance();  
268 -  
269 - ParameterSPtr p = plot->_parameterManager.getParameter(originalParamId);  
270 - AMDA::Info::ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());  
271 - if (paramInfo == nullptr)  
272 - return;  
273 -  
274 - Label label(pAxis->_legend.getFont(), pAxis->_legend.getColor());  
275 - addInfoPart(label._text, paramInfo->getShortName());  
276 - addInfoPart(label._text, paramInfo->getUnits());  
277 - pAxis->_legend.setLabel(label);  
278 -}  
279 -  
280 -void AxisLegendManager::setAxisLegendForTable(PanelPlotOutput* plot, boost::shared_ptr<Axis>& pAxis, std::string originalParamId, std::string paramId, AMDA::Common::ParameterIndexComponentList& indexes, int relatedDim) {  
281 - if (pAxis == nullptr || !pAxis->_legend.isEmpty()) {  
282 - return;  
283 - }  
284 -  
285 - // Retrieve ParamInfo Manager  
286 - ParamMgr* piMgr = ParamMgr::getInstance();  
287 -  
288 - ParameterSPtr p = plot->_parameterManager.getParameter(originalParamId);  
289 - AMDA::Info::ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());  
290 -  
291 - if (paramInfo == nullptr)  
292 - return;  
293 -  
294 - Label label(pAxis->_legend.getFont(), pAxis->_legend.getColor());  
295 - std::string info = getMissionInstrumentInfo(paramInfo);  
296 - if (!info.empty()) {  
297 - addInfoPart(label._text, info);  
298 - addBreakLine(label._text);  
299 - }  
300 -  
301 - boost::shared_ptr<AMDA::Info::ParamTable> tableSPtr;  
302 - tableSPtr = paramInfo->getTable(relatedDim);  
303 -  
304 - if (tableSPtr == nullptr) {  
305 - std::string tableInfo = "Table ";  
306 - tableInfo += std::to_string(relatedDim);  
307 - tableInfo += " indexes";  
308 - addInfoPart(label._text, tableInfo);  
309 - pAxis->_legend.pushLabel(label);  
310 - return;  
311 - }  
312 -  
313 - if (((*plot->_pParameterValues)[paramId].getDim1Size() > 0) &&  
314 - ((*plot->_pParameterValues)[paramId].getDim2Size() > 0) &&  
315 - !indexes.empty())  
316 - {  
317 - boost::shared_ptr<AMDA::Info::ParamTable> otherTableSPtr;  
318 - int otherDimIndex;  
319 - if (relatedDim == 0)  
320 - {  
321 - otherTableSPtr = paramInfo->getTable(1);  
322 - otherDimIndex = indexes.front().getDim2Index();  
323 - }  
324 - else  
325 - {  
326 - otherTableSPtr = paramInfo->getTable(0);  
327 - otherDimIndex = indexes.front().getDim1Index();  
328 - }  
329 - if ((otherTableSPtr != nullptr) && !otherTableSPtr->isVariable(&plot->_parameterManager))  
330 - {  
331 - if (otherTableSPtr->getName(&plot->_parameterManager).empty())  
332 - addInfoPart(label._text, "Table bounds");  
333 - else  
334 - addInfoPart(label._text, otherTableSPtr->getName(&plot->_parameterManager));  
335 -  
336 - AMDA::Info::t_TableBound crtBound = otherTableSPtr->getBound(&plot->_parameterManager, otherDimIndex);  
337 - addBoundsPart(label._text, crtBound.min, crtBound.max);  
338 - addInfoPart(label._text, otherTableSPtr->getUnits(&plot->_parameterManager));  
339 - }  
340 - else  
341 - {  
342 - std::string part = "Table Index: ";  
343 - part += std::to_string(otherDimIndex);  
344 - addInfoPart(label._text, part);  
345 - }  
346 - addBreakLine(label._text);  
347 - }  
348 - addInfoPart(label._text, tableSPtr->getName(&plot->_parameterManager));  
349 - addInfoPart(label._text, tableSPtr->getUnits(&plot->_parameterManager));  
350 - pAxis->_legend.pushLabel(label);  
351 -}  
352 -  
353 -void AxisLegendManager::addInfoPart(std::string& legend, std::string info) {  
354 - if (!info.empty()) {  
355 - if (!legend.empty()) {  
356 - if (legend.length() >= Label::DELIMITER.length()) {  
357 - if (legend.compare(legend.length() - Label::DELIMITER.length(), Label::DELIMITER.length(), Label::DELIMITER) != 0) {  
358 - legend += ", ";  
359 - }  
360 - }  
361 - else {  
362 - legend += ", ";  
363 - }  
364 - }  
365 - legend += info;  
366 - }  
367 -}  
368 -  
369 -void AxisLegendManager::addIndexPart(std::string& legend, ParameterIndexComponentColor& index) {  
370 - legend += "[";  
371 - legend += std::to_string(index.getDim1Index());  
372 - if (index.getDim2Index() != -1) {  
373 - legend += ",";  
374 - legend += std::to_string(index.getDim2Index());  
375 - }  
376 - legend += "]";  
377 -}  
378 -  
379 -void AxisLegendManager::addIndexPart(std::string& legend, int index) {  
380 - legend += "[";  
381 - legend += std::to_string(index);  
382 - legend += "]";  
383 -}  
384 -  
385 -void AxisLegendManager::addBoundsPart(std::string& legend, PLFLT min, PLFLT max) {  
386 - legend += " ";  
387 -  
388 - char minCount[1024];  
389 - char maxCount[1024];  
390 - 278 +
  279 + // Retrieve ParamInfo Manager
  280 + ParamMgr* piMgr = ParamMgr::getInstance();
  281 +
  282 + ParameterSPtr p = plot->_parameterManager.getParameter(originalParamId);
  283 + AMDA::Info::ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());
  284 +
  285 + if (paramInfo == nullptr)
  286 + return;
  287 +
  288 + Label label(pAxis->_legend.getFont(), pAxis->_legend.getColor());
  289 + std::string info = getMissionInstrumentInfo(paramInfo);
  290 + if (!info.empty()) {
  291 + addInfoPart(label._text, info);
  292 + addBreakLine(label._text);
  293 + }
  294 +
  295 + boost::shared_ptr<AMDA::Info::ParamTable> tableSPtr;
  296 + tableSPtr = paramInfo->getTable(relatedDim);
  297 +
  298 + if (tableSPtr == nullptr) {
  299 + std::string tableInfo = "Table ";
  300 + tableInfo += std::to_string(relatedDim);
  301 + tableInfo += " indexes";
  302 + addInfoPart(label._text, tableInfo);
  303 + pAxis->_legend.pushLabel(label);
  304 + return;
  305 + }
  306 +
  307 + if (((*plot->_pParameterValues)[paramId].getDim1Size() > 0) &&
  308 + ((*plot->_pParameterValues)[paramId].getDim2Size() > 0) &&
  309 + !indexes.empty()) {
  310 + boost::shared_ptr<AMDA::Info::ParamTable> otherTableSPtr;
  311 + int otherDimIndex;
  312 + if (relatedDim == 0) {
  313 + otherTableSPtr = paramInfo->getTable(1);
  314 + otherDimIndex = indexes.front().getDim2Index();
  315 + } else {
  316 + otherTableSPtr = paramInfo->getTable(0);
  317 + otherDimIndex = indexes.front().getDim1Index();
  318 + }
  319 + if ((otherTableSPtr != nullptr) && !otherTableSPtr->isVariable(&plot->_parameterManager)) {
  320 + if (otherTableSPtr->getName(&plot->_parameterManager).empty())
  321 + addInfoPart(label._text, "Table bounds");
  322 + else
  323 + addInfoPart(label._text, otherTableSPtr->getName(&plot->_parameterManager));
  324 +
  325 + AMDA::Info::t_TableBound crtBound = otherTableSPtr->getBound(&plot->_parameterManager, otherDimIndex);
  326 + addBoundsPart(label._text, crtBound.min, crtBound.max);
  327 + std::string rawUnit = otherTableSPtr->getUnits(&plot->_parameterManager);
  328 + addInfoPart(label._text, getTransformedUnits(rawUnit));
  329 + } else {
  330 + std::string part = "Table Index: ";
  331 + part += std::to_string(otherDimIndex);
  332 + addInfoPart(label._text, part);
  333 + }
  334 + addBreakLine(label._text);
  335 + }
  336 + addInfoPart(label._text, tableSPtr->getName(&plot->_parameterManager));
  337 + std::string rawUnit = tableSPtr->getUnits(&plot->_parameterManager);
  338 + addInfoPart(label._text, getTransformedUnits(rawUnit));
  339 + pAxis->_legend.pushLabel(label);
  340 + }
  341 +
  342 + void AxisLegendManager::addInfoPart(std::string& legend, std::string info) {
  343 + if (!info.empty()) {
  344 + if (!legend.empty()) {
  345 + if (legend.length() >= Label::DELIMITER.length()) {
  346 + if (legend.compare(legend.length() - Label::DELIMITER.length(), Label::DELIMITER.length(), Label::DELIMITER) != 0) {
  347 + legend += ", ";
  348 + }
  349 + } else {
  350 + legend += ", ";
  351 + }
  352 + }
  353 + legend += info;
  354 + }
  355 + }
  356 +
  357 + void AxisLegendManager::addIndexPart(std::string& legend, ParameterIndexComponentColor& index) {
  358 + legend += "[";
  359 + legend += std::to_string(index.getDim1Index());
  360 + if (index.getDim2Index() != -1) {
  361 + legend += ",";
  362 + legend += std::to_string(index.getDim2Index());
  363 + }
  364 + legend += "]";
  365 + }
  366 +
  367 + void AxisLegendManager::addIndexPart(std::string& legend, int index) {
  368 + legend += "[";
  369 + legend += std::to_string(index);
  370 + legend += "]";
  371 + }
  372 +
  373 + void AxisLegendManager::addBoundsPart(std::string& legend, PLFLT min, PLFLT max) {
  374 + legend += " ";
  375 +
  376 + char minCount[1024];
  377 + char maxCount[1024];
  378 +
391 int precision = computeScientificFormatPrecision(min, max); 379 int precision = computeScientificFormatPrecision(min, max);
392 - 380 +
393 getDigitalLabel(min, precision, minCount, 1024); 381 getDigitalLabel(min, precision, minCount, 1024);
394 getDigitalLabel(max, precision, maxCount, 1024); 382 getDigitalLabel(max, precision, maxCount, 1024);
395 383
396 - legend += std::string(minCount);  
397 - legend += ", ";  
398 - legend += std::string(maxCount);  
399 -}  
400 -  
401 -void AxisLegendManager::addBreakLine(std::string& legend) {  
402 - if (!legend.empty()) {  
403 - legend += Label::DELIMITER;  
404 - }  
405 -}  
406 -  
407 -std::string AxisLegendManager::getParamLegend(AMDA::Info::ParamInfoSPtr paramInfo, ParameterIndexComponentColor& index) {  
408 - std::string legend;  
409 - addInfoPart(legend, paramInfo->getShortName());  
410 -  
411 - if ((index.getDim1Index() != -1) || (index.getDim2Index() != -1)) {  
412 - AMDA::Common::ParameterIndexComponent paramIndex(index.getDim1Index(), index.getDim2Index());  
413 - if (paramInfo->getComponents(paramIndex).empty() == false)  
414 - addInfoPart(legend, paramInfo->getComponents(paramIndex));  
415 - else  
416 - {  
417 - addInfoPart(legend, paramInfo->getShortName());  
418 - addIndexPart(legend, index);  
419 - }  
420 - }  
421 -  
422 - addInfoPart(legend, paramInfo->getUnits());  
423 - addInfoPart(legend, paramInfo->getCoordinatesSystem());  
424 -  
425 - return legend;  
426 -}  
427 -  
428 -/*std::string AxisLegendManager::getParamLegend(AMDA::Info::ParamInfoSPtr paramInfo, int index) {  
429 - std::string legend;  
430 - addInfoPart(legend, paramInfo->getShortName());  
431 -  
432 - if ((index.getDim1Index() != -1) || (index.getDim2Index() != -1)) {  
433 - if (paramInfo->getComponents(index).empty() == false)  
434 - addInfoPart(legend, paramInfo->getComponents(index));  
435 - else  
436 - {  
437 - addInfoPart(legend, paramInfo->getShortName());  
438 - addIndexPart(legend, index);  
439 - } 384 + legend += std::string(minCount);
  385 + legend += ", ";
  386 + legend += std::string(maxCount);
  387 + }
  388 +
  389 + void AxisLegendManager::addBreakLine(std::string& legend) {
  390 + if (!legend.empty()) {
  391 + legend += Label::DELIMITER;
  392 + }
  393 + }
  394 +
  395 + std::string AxisLegendManager::getParamLegend(AMDA::Info::ParamInfoSPtr paramInfo, ParameterIndexComponentColor& index) {
  396 + std::string legend;
  397 + addInfoPart(legend, paramInfo->getShortName());
  398 +
  399 + if ((index.getDim1Index() != -1) || (index.getDim2Index() != -1)) {
  400 + AMDA::Common::ParameterIndexComponent paramIndex(index.getDim1Index(), index.getDim2Index());
  401 + if (paramInfo->getComponents(paramIndex).empty() == false)
  402 + addInfoPart(legend, paramInfo->getComponents(paramIndex));
  403 + else {
  404 + addInfoPart(legend, paramInfo->getShortName());
  405 + addIndexPart(legend, index);
  406 + }
440 } 407 }
441 408
442 - addInfoPart(legend, paramInfo->getUnits()); 409 + addInfoPart(legend, getTransformedUnits(paramInfo->getUnits()));
443 addInfoPart(legend, paramInfo->getCoordinatesSystem()); 410 addInfoPart(legend, paramInfo->getCoordinatesSystem());
444 411
445 return legend; 412 return legend;
446 -}*/  
447 -  
448 -std::string AxisLegendManager::getMissionInstrumentInfo(AMDA::Info::ParamInfoSPtr paramInfo) {  
449 - std::string info = paramInfo->getInstrumentId();  
450 - if (info.empty())  
451 - return info;  
452 - std::replace(info.begin(), info.end(), '_', ' ');  
453 - std::transform(info.begin(), info.end(), info.begin(), ::toupper);  
454 - return info;  
455 -}  
456 -  
457 -std::string AxisLegendManager::getMissionInfo(AMDA::Info::ParamInfoSPtr paramInfo) {  
458 - std::string info = paramInfo->getInstrumentId();  
459 - if (info.empty())  
460 - return info;  
461 - if (info.find('_') != std::string::npos) {  
462 - info = info.substr(0, info.find('_'));  
463 - }  
464 - std::transform(info.begin(), info.end(), info.begin(), ::toupper);  
465 - return info;  
466 -} 413 + }
  414 +
  415 + /*std::string AxisLegendManager::getParamLegend(AMDA::Info::ParamInfoSPtr paramInfo, int index) {
  416 + std::string legend;
  417 + addInfoPart(legend, paramInfo->getShortName());
  418 +
  419 + if ((index.getDim1Index() != -1) || (index.getDim2Index() != -1)) {
  420 + if (paramInfo->getComponents(index).empty() == false)
  421 + addInfoPart(legend, paramInfo->getComponents(index));
  422 + else
  423 + {
  424 + addInfoPart(legend, paramInfo->getShortName());
  425 + addIndexPart(legend, index);
  426 + }
  427 + }
  428 +
  429 + addInfoPart(legend, paramInfo->getUnits());
  430 + addInfoPart(legend, paramInfo->getCoordinatesSystem());
  431 +
  432 + return legend;
  433 + }*/
  434 +
  435 + std::string AxisLegendManager::getMissionInstrumentInfo(AMDA::Info::ParamInfoSPtr paramInfo) {
  436 + std::string info = paramInfo->getInstrumentId();
  437 + if (info.empty())
  438 + return info;
  439 + std::replace(info.begin(), info.end(), '_', ' ');
  440 + std::transform(info.begin(), info.end(), info.begin(), ::toupper);
  441 + return info;
  442 + }
  443 +
  444 + std::string AxisLegendManager::getMissionInfo(AMDA::Info::ParamInfoSPtr paramInfo) {
  445 + std::string info = paramInfo->getInstrumentId();
  446 + if (info.empty())
  447 + return info;
  448 + if (info.find('_') != std::string::npos) {
  449 + info = info.substr(0, info.find('_'));
  450 + }
  451 + std::transform(info.begin(), info.end(), info.begin(), ::toupper);
  452 + return info;
  453 + }
  454 +
  455 + std::string AxisLegendManager::getTransformedUnits(const std::string& rawUnit) {
  456 + std::string unit = rawUnit;
  457 + if (unit.find("^"))
  458 + unit = transformPower(unit, "^");
  459 + if (unit.find("**"))
  460 + unit = transformPower(unit, "**");
  461 + return unit;
  462 + }
  463 +
  464 + std::string AxisLegendManager::transformPower(std::string& unit, std::string pattern) {
  465 + std::map<size_t, size_t> positions; // holds all the positions that pattern occurs within unit
  466 + size_t pos_first = unit.find(pattern, 0);
  467 + size_t pos_last;
  468 + while (pos_first != std::string::npos) {
  469 + char afterPattern = unit[pos_first + pattern.length()];
  470 + pos_last = pos_first + pattern.length();
  471 + if(afterPattern == '+' || afterPattern =='-'){
  472 + afterPattern = unit[pos_first + pattern.length()+1];
  473 + pos_last ++;
  474 + }
  475 + if (afterPattern == '('){
  476 + pos_last = unit.find(")", pos_first + pattern.length())+1;
  477 + }else if(afterPattern == '|'){
  478 + pos_last = unit.find("|", pos_first + pattern.length()+2)+1;
  479 + }
  480 + else if( isdigit(afterPattern) || afterPattern == '.'){
  481 + pos_last ++;
  482 + while(isdigit(unit[pos_last]) || unit[pos_last] == '.'){
  483 + pos_last ++;
  484 + }
  485 + }else{
  486 + pos_last ++;
  487 + }
  488 + positions.insert(std::pair<size_t, size_t>(pos_first, pos_last));
  489 + pos_first = unit.find(pattern, pos_first + pattern.length());
  490 + }
  491 + std::map<size_t, size_t>::reverse_iterator it;
  492 + for (it = positions.rbegin(); it != positions.rend(); ++it) {
  493 + unit.insert(it->second, "#d");
  494 + unit.erase(it->first, pattern.length());
  495 + unit.insert(it->first, "#u");
  496 + }
  497 + return unit;
  498 + }
  499 +
467 500
468 } /* namespace plot */ 501 } /* namespace plot */
src/ParamOutputImpl/Plot/AxisLegendManager.hh
  Diff comments   View file @b92d255
@@ -91,6 +91,10 @@ class AxisLegendManager { @@ -91,6 +91,10 @@ class AxisLegendManager {
91 static std::string getMissionInstrumentInfo(AMDA::Info::ParamInfoSPtr paramInfo); 91 static std::string getMissionInstrumentInfo(AMDA::Info::ParamInfoSPtr paramInfo);
92 92
93 static std::string getMissionInfo(AMDA::Info::ParamInfoSPtr paramInfo); 93 static std::string getMissionInfo(AMDA::Info::ParamInfoSPtr paramInfo);
  94 +
  95 + static std::string getTransformedUnits(const std::string& rawUnit);
  96 +
  97 + static std::string transformPower(std::string& unit, std::string pattern);
94 }; 98 };
95 99
96 } 100 }