]> SALOME platform Git repositories - modules/gui.git/blob - src/Plot2d/Plot2d_AnalyticalCurve.cxx
Salome HOME
Merge branch 'origin/akl/single_desktop'
[modules/gui.git] / src / Plot2d / Plot2d_AnalyticalCurve.cxx
1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //  File   : Plot2d_AnalyticalCurve.cxx
23 //  Author : Roman NIKOLAEV, Open CASCADE S.A.S. (roman.nikolaev@opencascade.com)
24
25 #include "Plot2d_AnalyticalParser.h"
26 #include "Plot2d_AnalyticalCurve.h"
27 #include "Plot2d_PlotItems.h"
28 #include "Plot2d_Object.h"
29
30 #include <qwt_scale_div.h>
31
32
33 //Init static data;
34
35 int Plot2d_AnalyticalCurve::myNbCurves = 0;
36
37 /*!
38   Constructor
39 */
40 Plot2d_AnalyticalCurve::Plot2d_AnalyticalCurve() : 
41   myAutoAssign(true),
42   myColor( 0, 0, 0 ), 
43   myMarker( Plot2d::Circle ), 
44   myMarkerSize( 0 ), 
45   myLine( Plot2d::Solid ), 
46   myLineWidth( 0 ),
47   myRangeBegin(0.0),
48   myRangeEnd(100.0),
49   myNbIntervals(100),
50   myExpression(""),
51   myAction(Plot2d_AnalyticalCurve::ActAddInView),
52   myState(Plot2d_AnalyticalCurve::StateNeedUpdate),
53   myCurve(0),
54   myActive(true),
55   myIsSelected(false)
56 {
57   myName = QString("Analytical Curve %1").arg(++myNbCurves);
58 }
59
60
61 /*!
62   Destructor
63 */
64 Plot2d_AnalyticalCurve::~Plot2d_AnalyticalCurve()
65 {
66 }
67
68 /*!
69   Copy constructor. Makes deep copy of data
70 */
71 Plot2d_AnalyticalCurve::Plot2d_AnalyticalCurve( const Plot2d_AnalyticalCurve& curve )
72 {
73   myAutoAssign = curve.isAutoAssign();
74   myColor      = curve.getColor();
75   myMarker     = curve.getMarker();
76   myMarkerSize = curve.getMarkerSize();
77   myLine       = curve.getLine();
78   myLineWidth  = curve.getLineWidth();
79   myRangeBegin = curve.getRangeBegin();
80   myRangeEnd   = curve.getRangeEnd();
81   myNbIntervals= curve.getNbIntervals();
82   myPoints     = curve.myPoints;
83   myAction     = curve.getAction();
84   myName       = curve.getName();
85   myExpression = curve.getExpression();
86   myState      = curve.state();
87   myCurve      = curve.myCurve;
88   myActive     = curve.isActive();
89 }
90
91 /*!
92   operator=. Makes deep copy of data
93 */
94 Plot2d_AnalyticalCurve& Plot2d_AnalyticalCurve::operator=( const Plot2d_AnalyticalCurve& curve )
95 {
96   myAutoAssign = curve.isAutoAssign();
97   myColor      = curve.getColor();
98   myMarker     = curve.getMarker();
99   myMarkerSize = curve.getMarkerSize();
100   myLine       = curve.getLine();
101   myLineWidth  = curve.getLineWidth();
102   myRangeBegin = curve.getRangeBegin();
103   myRangeEnd   = curve.getRangeEnd();
104   myNbIntervals= curve.getNbIntervals();
105   myPoints     = curve.myPoints;
106   myAction     = curve.getAction();
107   myName       = curve.getName();
108   myExpression = curve.getExpression();
109   myState      = curve.state();
110   myCurve      = curve.myCurve;
111   myActive     = curve.isActive();
112   return *this;
113 }
114
115 /*!
116   Create plot object for the curve
117 */
118 QwtPlotItem* Plot2d_AnalyticalCurve::plotItem()
119 {
120   if(!myCurve) {
121     myCurve = new Plot2d_QwtPlotCurve(QString(""));
122     updatePlotItem();
123   }
124   return myCurve;
125 }
126
127 /*!
128   Auto fill parameters of object by plot view
129 */
130 void Plot2d_AnalyticalCurve::autoFill( const QwtPlot* thePlot )
131 {
132   QwtSymbol::Style typeMarker;
133   QColor           color;
134   Qt::PenStyle     typeLine;
135   Plot2d::getNextMarker( QwtPlotItem::Rtti_PlotCurve, thePlot, typeMarker, color, typeLine );
136   
137   setColor( color );
138   setLine( Plot2d::qwt2plotLine( typeLine ));
139   setLineWidth(1);
140   setMarker( Plot2d::qwt2plotMarker( typeMarker ) );
141 }
142
143 /*!
144   Updates curve fields
145 */
146 void Plot2d_AnalyticalCurve::updatePlotItem()
147 {
148   if ( !myCurve )
149     return;
150
151   Plot2d_QwtPlotCurve* aCurve = dynamic_cast<Plot2d_QwtPlotCurve*>(myCurve);
152
153   if(!aCurve)
154     return;
155   
156   Qt::PenStyle     ps = Plot2d::plot2qwtLine( getLine() );
157   QwtSymbol::Style ms = Plot2d::plot2qwtMarker( getMarker() );
158
159   QColor aColor = isSelected() ?  Plot2d_Object::selectionColor() : getColor();
160   int lineW = getLineWidth(); 
161   if ( isSelected() ) lineW += (lineW == 0 ? 3 : 2);
162
163   int markerS = isSelected() ? getMarkerSize() + 2 : getMarkerSize();
164
165   aCurve->setSelected(isSelected());
166
167   aCurve->setPen( QPen(aColor , lineW, ps ) );
168   aCurve->setSymbol( new QwtSymbol( ms, QBrush( aColor ),
169                                     QPen( aColor ),
170                                     QSize( markerS , markerS ) ) );
171
172   aCurve->setLegendPen(QPen(getColor(), getLineWidth(), ps ));
173   aCurve->setLegendSymbol( new QwtSymbol( ms, QBrush( getColor() ),
174                                           QPen( getColor() ),
175                                           QSize( getMarkerSize() , getMarkerSize() )));
176
177   double *x, *y;
178   long nb = getData( &x, &y );
179   aCurve->setSamples( x, y, nb );
180   aCurve->setTitle(getName());
181 }
182
183
184 /*!
185   Calculate the curve points.
186 */
187 void Plot2d_AnalyticalCurve::calculate() {
188   if( state() == Plot2d_AnalyticalCurve::StateOk )
189     return;
190
191   if(myRangeBegin > myRangeEnd)
192     return;
193
194   Plot2d_AnalyticalParser* parser = Plot2d_AnalyticalParser::parser();
195   double* x = 0;
196   double* y = 0;
197   int nb = parser->calculate(getExpression(), getRangeBegin(), getRangeEnd(),
198                              getNbIntervals(),&x,&y);
199   if( nb > 0 ) {
200     myPoints.clear();
201     for( int i = 0; i < nb; i++ ) {
202       Plot2d_Point pnt(x[i], y[i]);
203       myPoints.append(pnt);
204     }
205     delete x;
206     delete y;
207     myState = Plot2d_AnalyticalCurve::StateOk;
208     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
209   }
210 }
211 /*!
212   Checks that this curve can be computed for the input QwtPlot
213 */
214 bool Plot2d_AnalyticalCurve::checkCurve( const QwtPlot* thePlot) {
215   if( !myExpression.isEmpty() && thePlot ) {
216     const QwtScaleDiv div = thePlot->axisScaleDiv(QwtPlot::xBottom);
217     setRangeBegin(div.lowerBound());
218     setRangeEnd(div.upperBound());
219     calculate();
220   }
221   return myState == Plot2d_AnalyticalCurve::StateOk;
222 }
223
224
225 /*!
226   Gets object's data
227 */
228 long Plot2d_AnalyticalCurve::getData( double** theX, double** theY ) const
229 {
230   int aNPoints = myPoints.size();
231   *theX = new double[aNPoints];
232   *theY = new double[aNPoints];
233   for (int i = 0; i < aNPoints; i++) {
234     (*theX)[i] = myPoints[i].x;
235     (*theY)[i] = myPoints[i].y;
236   }
237   return aNPoints;
238 }
239
240 /*!
241   Sets curves's AutoAssign flag - in this case attributes will be set automatically
242 */
243 void Plot2d_AnalyticalCurve::setAutoAssign( bool on )
244 {
245   if( myAutoAssign != on ) {
246     myAutoAssign = on;
247     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
248   }
249 }
250
251 /*!
252   Gets curve's AutoAssign flag state
253 */
254 bool Plot2d_AnalyticalCurve::isAutoAssign() const
255 {
256   return myAutoAssign;
257 }
258
259 /*!
260   Sets curve's color.
261 */
262 void Plot2d_AnalyticalCurve::setColor( const QColor& color )
263 {
264   if(myColor != color) {
265     myColor = color;
266     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
267   }
268 }
269
270 /*!
271   Gets curve's color
272 */
273 QColor Plot2d_AnalyticalCurve::getColor() const
274 {
275   return myColor;
276 }
277
278
279 /*!
280   Sets marker type ( and resets AutoAssign flag )
281 */
282 void Plot2d_AnalyticalCurve::setMarker( Plot2d::MarkerType marker )
283 {
284   if(myMarker != marker) {
285     myMarker = marker;
286     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
287   }
288 }
289
290 /*!
291   Gets marker type
292 */
293 Plot2d::MarkerType Plot2d_AnalyticalCurve::getMarker() const
294 {
295   return myMarker;
296 }
297
298 /*!
299   Sets new marker size
300 */
301 void Plot2d_AnalyticalCurve::setMarkerSize( const int theSize )
302 {
303   if( myMarkerSize != theSize ) {
304     myMarkerSize = theSize < 0 ? 0 : theSize;
305     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
306   }
307 }
308
309 /*!
310   Gets marker size
311 */
312 int Plot2d_AnalyticalCurve::getMarkerSize() const
313 {
314   return myMarkerSize;
315 }
316
317 /*!
318   Sets line type
319 */
320 void Plot2d_AnalyticalCurve::setLine( Plot2d::LineType line )
321 {
322   if(myLine != line) {
323     myLine = line;
324     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
325   }
326 }
327
328 /*!
329   Gets line type
330 */
331 Plot2d::LineType Plot2d_AnalyticalCurve::getLine() const
332 {
333   return myLine;
334 }
335
336
337 /*!
338   Sets line width
339 */
340 void Plot2d_AnalyticalCurve::setLineWidth( const int lineWidth )
341 {
342   if( myLineWidth != lineWidth ) {
343     myLineWidth = lineWidth < 0 ? 0 : lineWidth;
344     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
345   }
346 }
347
348 /*!
349   Gets line width
350 */
351 int Plot2d_AnalyticalCurve::getLineWidth() const
352 {
353   return myLineWidth;
354 }
355
356 /*!
357   Sets number of points
358 */
359 void Plot2d_AnalyticalCurve::setNbIntervals( const long nb )
360 {
361   if( myNbIntervals != nb ) {
362     myNbIntervals = nb < 1 ? 1 : nb;
363     myState = Plot2d_AnalyticalCurve::StateNeedUpdate;
364   }
365 }
366
367 /*!
368   Gets number of points
369 */
370 long Plot2d_AnalyticalCurve::getNbIntervals() const
371 {
372   return myNbIntervals;
373 }
374
375 /*!
376   Sets X coordinate of the first curve points
377 */
378 void Plot2d_AnalyticalCurve::setRangeBegin( const double coord) {
379   if( myRangeBegin != coord ) {
380     myRangeBegin = coord;
381     myState = Plot2d_AnalyticalCurve::StateNeedUpdate;
382   }
383 }
384
385 /*!
386   Gets X coordinate of the first curve points
387 */
388 double Plot2d_AnalyticalCurve::getRangeBegin() const {
389   return myRangeBegin;
390 }
391
392 /*!
393   Sets X coordinate of the last curve points
394 */
395 void Plot2d_AnalyticalCurve::setRangeEnd( const double coord) {
396   if( myRangeEnd != coord ) {
397     myRangeEnd = coord;
398     myState = Plot2d_AnalyticalCurve::StateNeedUpdate;
399   }
400 }
401
402 /*!
403   Gets X coordinate of the last curve points
404 */
405 double Plot2d_AnalyticalCurve::getRangeEnd() const {
406   return myRangeEnd;
407 }
408
409 /*!
410   Sets the curve expression.
411 */
412 void Plot2d_AnalyticalCurve::setExpression( const QString& expr ) {
413   if( myExpression != expr ) {
414     myExpression = expr;
415     myState = Plot2d_AnalyticalCurve::StateNeedUpdate;
416   }
417 }
418
419 /*!
420   Gets the curve expression.
421 */
422 QString Plot2d_AnalyticalCurve::getExpression() const {
423   return  myExpression;
424 }
425
426 /*!
427   Sets the curve name.
428 */
429 void Plot2d_AnalyticalCurve::setName( const QString& name ) {
430   if( myName != name ) {    
431     myName = name;
432     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
433   }
434 }
435
436 /*!
437   Gets the curve name.
438 */
439 QString Plot2d_AnalyticalCurve::getName() const {
440   return myName;
441 }
442
443
444 /*!
445   Sets the curve action.
446 */
447 void Plot2d_AnalyticalCurve::setAction(const int act) {
448   if( act == Plot2d_AnalyticalCurve::ActNothing ) {
449     myAction = act;
450     return;
451   }
452   
453   if(myAction != Plot2d_AnalyticalCurve::ActAddInView && 
454      myAction != Plot2d_AnalyticalCurve::ActRemoveFromView) {
455     myAction = act;  
456   }
457 }
458
459 /*!
460   Gets the curve action.
461 */
462 int Plot2d_AnalyticalCurve::getAction() const {
463   return myAction;
464 }
465
466 /*!
467   Gets the curve state.
468 */
469 int Plot2d_AnalyticalCurve::state() const {
470   return myState;
471 }
472
473 /*!
474   Sets the curve active status.
475 */
476 void Plot2d_AnalyticalCurve::setActive(const bool on) {
477   if( myActive != on ) {    
478     if(myActive && !on)
479       setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
480     else if(!myActive && on) {
481       setAction(Plot2d_AnalyticalCurve::ActAddInView);
482       myState = Plot2d_AnalyticalCurve::StateNeedUpdate;
483     }
484     myActive = on;
485   }  
486 }
487
488 /*!
489   Gets the curve active status.
490 */
491 bool Plot2d_AnalyticalCurve::isActive() const {
492   return myActive;
493 }
494
495
496 /*!
497   Sets curve's selected property.
498 */
499 void Plot2d_AnalyticalCurve::setSelected(const bool on) {
500   if(myIsSelected != on) {
501         myIsSelected  = on;
502     setAction(Plot2d_AnalyticalCurve::ActUpdateInView);
503   }
504
505 }
506
507 /*!
508   Gets curve's selected property.
509 */
510 bool Plot2d_AnalyticalCurve::isSelected() const {
511   return myIsSelected;
512 }