void OscilloscopePlot::updateCurve()
{
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->values().lock();
const int numPoints = data->size();
if ( numPoints > d_paintedPoints )
{
const bool doClip = !canvas()->testAttribute( Qt::WA_PaintOnScreen );
if ( doClip )
{
/*
Depending on the platform setting a clip might be an important
performance issue. F.e. for Qt Embedded this reduces the
part of the backing store that has to be copied out - maybe
to an unaccelerated frame buffer device.
*/
const QwtScaleMap xMap = canvasMap( d_curve->xAxis() );
const QwtScaleMap yMap = canvasMap( d_curve->yAxis() );
QRectF br = qwtBoundingRect( *data,
d_paintedPoints - 1, numPoints - 1 );
const QRect clipRect = QwtScaleMap::transform( xMap, yMap, br ).toRect();
d_directPainter->setClipRegion( clipRect );
}
d_directPainter->drawSeries( d_curve,
d_paintedPoints - 1, numPoints - 1 );
d_paintedPoints = numPoints;
}
data->values().unlock();
}
boost::shared_ptr<BlackCapFloorEngine> MustCapFloor::setEngineQuantLibBalckFT(){
CurveData cData;
// Fill out with some sample market data
cData.sampleMktData(cData);
// Build a curve linked to this market data
boost::shared_ptr<YieldTermStructure> ocurve = (cData.buildCurve(cData));
// Link the curve to the term structure
this->forwardingTermStructure.linkTo(ocurve);
//Date today(6, October, 2014);
Settings::instance().evaluationDate() = today;
//Date todaysDate = Date(8, Apr, 2015);
//capletsVolatilies = buildCurveOptionletAtmVol(cVol);
//capletsVolatilies = buildOptionletSurfaceVol(cVol);
//capletsVolatilies = buildOptionletCurveVol(cVol);
cVol.termStructure.linkTo(ocurve);
capletsVolatilies = (cVol.buildFlatCurveVol(cVol));
//capVol->enableExtrapolation();
return boost::shared_ptr<BlackCapFloorEngine>(new
BlackCapFloorEngine(forwardingTermStructure, capletsVolatilies));
}
void IncrementalPlot::appendPoint( const QPointF &point )
{
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->append( point );
const bool doClip = !canvas()->testAttribute( Qt::WA_PaintOnScreen );
// if ( doClip )
// {
// /*
// Depending on the platform setting a clip might be an important
// performance issue. F.e. for Qt Embedded this reduces the
// part of the backing store that has to be copied out - maybe
// to an unaccelerated frame buffer device.
// */
// const QwtScaleMap xMap = canvasMap( d_curve->xAxis() );
// const QwtScaleMap yMap = canvasMap( d_curve->yAxis() );
// QRegion clipRegion;
// const QSize symbolSize = d_curve->symbol()->size();
// QRect r( 0, 0, symbolSize.width() + 2, symbolSize.height() + 2 );
// const QPointF center =
// QwtScaleMap::transform( xMap, yMap, point );
// r.moveCenter( center.toPoint() );
// clipRegion += r;
// d_directPainter->setClipRegion( clipRegion );
// }
d_directPainter->drawSeries( d_curve,
data->size() - 1, data->size() - 1 );
}
void BrainPlot::clearPoints(int Channel)
{
CurveData *data = static_cast<CurveData *>( d_curves[Channel]->data() );
data->clear();
replot();
}
void IncrementalPlot::clearPoints()
{
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->clear();
replot();
}
void OscilloscopePlot::incrementInterval()
{
d_interval = QwtInterval( d_interval.maxValue(),
d_interval.maxValue() + d_interval.width() );
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->values().clearStaleValues( d_interval.minValue() );
// To avoid, that the grid is jumping, we disable
// the autocalculation of the ticks and shift them
// manually instead.
QwtScaleDiv scaleDiv = axisScaleDiv( QwtPlot::xBottom );
scaleDiv.setInterval( d_interval );
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
{
QList<double> ticks = scaleDiv.ticks( i );
for ( int j = 0; j < ticks.size(); j++ )
ticks[j] += d_interval.width();
scaleDiv.setTicks( i, ticks );
}
setAxisScaleDiv( QwtPlot::xBottom, scaleDiv );
d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );
d_paintedPoints = 0;
replot();
}
void Wykres2d::wyczysc()
{
CurveData *data = static_cast<CurveData *> (plot2dCurve->data());
data->clear();
punkty.clear();
plot2d->replot();
}
// -------------------------------------------------------------------------- //
//
void Test_CurveData::testGetChi2New()
{
CurveData cd;
const double chi2_new = 1.1246722311651241;
cd.chi2_new_ = chi2_new;
CPPUNIT_ASSERT_DOUBLES_EQUAL( cd.get_chi2_new(), chi2_new, 1.0e-12 );
}
void Plot::replot()
{
CurveData *data = (CurveData *)d_curve->data();
data->values().lock();
QwtPlot::replot();
d_paintedPoints = data->size();
data->values().unlock();
}
void OscilloscopePlot::replot()
{
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->values().lock();
QwtPlot::replot();
d_paintedPoints = data->size();
data->values().unlock();
}
void BrainPlot::appendPoint( QPointF point, int Channel )
{
/*Adds new point - with proper index and offset - to the data series*/
CurveData *data = static_cast<CurveData *>( d_curves[Channel]->data() );
point.setY(minusExpectedAmplitude*(2*Channel+1)+point.y());
data->replace(sample%plotLength, point);
setClipRegion(d_curves[Channel], point);
d_directPainter->drawSeries( d_curves[Channel],
data->size() - 1, data->size() - 1 );
}
void Plot::updateCurve()
{
CurveData *data = (CurveData *)d_curve->data();
data->values().lock();
const int numPoints = d_curve->data()->size();
if ( numPoints > d_paintedPoints )
{
d_directPainter->drawSeries(d_curve,
d_paintedPoints - 1, numPoints - 1);
d_paintedPoints = numPoints;
}
data->values().unlock();
}
void Wykres2d::aktualizuj()
{
CurveData *data = static_cast<CurveData *> (plot2dCurve->data());
data->clear();
for (int i = 0; i < punkty.size(); i++) {
data->append(punkty[i]);
}
plot2d->replot();
}
boost::shared_ptr<AnalyticCapFloorEngine> MustCapFloor::setEngineQuantLibLMM(){
CurveData cData;
// Fill out with some sample market data
cData.sampleMktData(cData);
//Date today(10, October, 2014);
//Settings::instance().evaluationDate() = today;
// Build a curve linked to this market data
boost::shared_ptr<YieldTermStructure> ocurve = (cData.buildCurve(cData));
// Link the curve to the term structure
boost::shared_ptr<IborIndex> index = boost::shared_ptr<IborIndex>(new Euribor6M(forwardingTermStructure));
Date todaysDate =
myIndex->fixingCalendar().adjust(today);
Settings::instance().evaluationDate() = todaysDate;
this->forwardingTermStructure.linkTo(ocurve);
const Size size = floatingLeg.size();
boost::shared_ptr<LiborForwardModelProcess> process(
new LiborForwardModelProcess(size, myIndex));
//// set-up the model
///* const Real a = 0.02;
//const Real b = 0.12;
//const Real c = 0.1;
//const Real d = 0.01;*/
const Real a = 0.025;
const Real b = 0.12;
const Real c = 0.1;
const Real d = 0.01;
boost::shared_ptr<LmVolatilityModel> volaModel(
new LmLinearExponentialVolatilityModel(process->fixingTimes(), a, b, c, d));
boost::shared_ptr<LmCorrelationModel> corrModel(
new LmLinearExponentialCorrelationModel(size, 0.1, 0.1));
boost::shared_ptr<LiborForwardModel> liborModel(
new LiborForwardModel(process, volaModel, corrModel));
return boost::shared_ptr<AnalyticCapFloorEngine> (
new AnalyticCapFloorEngine(liborModel, forwardingTermStructure));
}
void BrainPlot::timeStep(std::vector<float> data) {
/*Curves*/
for(int c = 0; c < nChannels; c++)
appendPoint(QPointF(sample%plotLength, data[c]), c);
/*Sweep line*/
CurveData *sweep = static_cast<CurveData *>( d_sweep->data() );
sweep->replace(0, QPointF((sample)%plotLength, plotLength));
sweep->replace(1, QPointF((sample)%plotLength, 2*nChannels*minusExpectedAmplitude));
setClipRegion(d_sweep, QPointF(0,0));
d_directPainter->drawSeries( d_sweep, 0, 1);
/*Time step*/
sample++;
/*Refreshes plot*/
replot();
}
void StringToCurve::UpdateCurve()
{
// Remove any existing curves
while ( !m_OutCurveList->getCurveList().empty() ) {
delete m_OutCurveList->getCurveList().back();
m_OutCurveList->getCurveList().pop_back();
}
std::string dataString = f_CurveString->getStringValue();
dataString.append( f_CurveSeparator->getStringValue() );
std::string indexString = f_IndexString->getStringValue();
std::vector< float > indexValues;
if (indexString.length() != 0 ){
StringToVector(indexString, indexValues );
}
if ( dataString.length() > 0 ){
// Split string into curves
std::vector<std::string> curves;
boost::split(curves, dataString, boost::is_any_of(f_CurveSeparator->getStringValue() ));
// Iterate over curves
std::vector<std::string>::iterator stringIt = curves.begin();
for (;stringIt < curves.end(); ++stringIt ){
std::string curCurve = *stringIt;
if (curCurve.length() == 0) {continue;}
// Remove leading and trailing spaces
boost::trim( curCurve );
std::vector< MLfloat > curveValues;
StringToVector( curCurve, curveValues );
CurveData *outputCurve = new CurveData;
outputCurve->setY( curveValues.size(),&curveValues[0], 1 );
if ( f_IndexString->getStringValue().length() != 0 ){
outputCurve->setX( indexValues.size(),&indexValues[0], 1 );
}
m_OutCurveList->getCurveList().push_back( outputCurve );
}
}
}
void Plot::appendPoint1(double u)
{
double elapsed = d_clock.elapsed() / 1000.0;
qDebug() << "d_clock1: " << elapsed;
qDebug() << "udouble1: " << u;
QPointF point(elapsed,(u*5/1024));
CurveData *data = static_cast<CurveData *>( d_curve1->data() );
data->append(point);
RecToFile1(elapsed,u);
const int numPoints = data->size();
if ( numPoints > d_paintedPoints1 )
{
const bool doClip = !canvas()->testAttribute( Qt::WA_PaintOnScreen );
if ( doClip )
{
/*
Depending on the platform setting a clip might be an important
performance issue. F.e. for Qt Embedded this reduces the
part of the backing store that has to be copied out - maybe
to an unaccelerated frame buffer device.
*/
const QwtScaleMap xMap = canvasMap( d_curve1->xAxis() );
const QwtScaleMap yMap = canvasMap( d_curve1->yAxis() );
QRectF br = qwtBoundingRect( *data,
d_paintedPoints1 - 1, numPoints - 1 );
const QRect clipRect = QwtScaleMap::transform( xMap, yMap, br ).toRect();
d_directPainter0->setClipRegion( clipRect );
}
d_directPainter0->drawSeries(d_curve1,
d_paintedPoints1 - 1, numPoints - 1);
d_paintedPoints1 = numPoints;
}
}
BrainPlot::BrainPlot(QWidget *parent, int nChannels, int Length, int Amplitude):
QwtPlot( parent ),
d_curves( nChannels ),
d_zeros( nChannels )
{
/*Set some attributes*/
minusExpectedAmplitude = -Amplitude;
plotLength = Length;
this->nChannels = nChannels;
/*Start sample counter*/
sample = 0;
/*Painter*/
d_directPainter = new QwtPlotDirectPainter( this );
if ( QwtPainter::isX11GraphicsSystem() )
{
#if QT_VERSION < 0x050000
canvas()->setAttribute( Qt::WA_PaintOutsidePaintEvent, true );
#endif
canvas()->setAttribute( Qt::WA_PaintOnScreen, true );
}
/*Activates the legend for channel tracking*/
QwtLegend *legend = new QwtLegend;
legend->setDefaultItemMode( QwtLegendData::ReadOnly);
insertLegend( legend, QwtPlot::LeftLegend );
/*Instantiate the reference lines and the data curves for each channel*/
int Hfactor = 360/(nChannels+1);//different colors for each curve
char name[15];
for(int c = 0; c < nChannels; c++) {
/*Curve*/
sprintf(name, "Channel %d", c+1);
d_curves[c] = new QwtPlotCurve( name);
d_curves[c]->setData( new CurveData(plotLength,
minusExpectedAmplitude*(2*c+1)) );
d_curves[c]->setPen( QColor::fromHsv ( Hfactor*c, 255, 255));
d_curves[c]->setStyle( QwtPlotCurve::Lines );
d_curves[c]->setSymbol( new QwtSymbol( QwtSymbol::NoSymbol));
d_curves[c]->attach( this );
/*Reference line*/
d_zeros[c] = new QwtPlotCurve;
d_zeros[c]->setData( new CurveData() );
d_zeros[c]->setPen( QColor::fromHsv ( Hfactor*c, 255, 140));
d_zeros[c]->setStyle( QwtPlotCurve::Lines );
d_zeros[c]->setSymbol( new QwtSymbol( QwtSymbol::NoSymbol));
d_zeros[c]->setItemAttribute(QwtPlotItem::Legend, false);
d_zeros[c]->attach( this );
/*Draw reference lines*/
CurveData *data = static_cast<CurveData *>( d_zeros[c]->data() );
data->append(QPointF(0, minusExpectedAmplitude*(2*c+1)));
data->append(QPointF(plotLength, minusExpectedAmplitude*(2*c+1)));
d_directPainter->drawSeries( d_zeros[c], 0, 1);
}
/*Sweeping line*/
d_sweep = new QwtPlotCurve;
d_sweep->setData( new CurveData() );
d_sweep->setPen( Qt::black, plotLength/100, Qt::SolidLine);
d_sweep->setStyle( QwtPlotCurve::Lines );
d_sweep->setSymbol( new QwtSymbol( QwtSymbol::NoSymbol));
d_sweep->setItemAttribute(QwtPlotItem::Legend, false);
d_sweep->attach( this );
CurveData *data = static_cast<CurveData *>( d_sweep->data() );
data->append(QPointF(0, plotLength));
data->append(QPointF(0, 2*nChannels*minusExpectedAmplitude));
/*Axis*/
setAxisScale( xBottom, 0, plotLength );
setAxisScale( yLeft, 2*nChannels*minusExpectedAmplitude, 0 );
enableAxis(xBottom, false);
enableAxis(yLeft, false);
/*Frame*/
setFrameStyle( QFrame::NoFrame );
setLineWidth( 0 );
/*Canvas*/
plotLayout()->setAlignCanvasToScales( true );
plotLayout()->setCanvasMargin(100, QwtPlot::xBottom);
plotLayout()->setCanvasMargin(100, QwtPlot::xTop);
setCanvasBackground( Qt::black );
/*Grid*/
QwtPlotGrid *grid = new QwtPlotGrid;
grid->setMajorPen( Qt::gray, 0, Qt::DotLine );
grid->setMinorPen( Qt::gray, 0, Qt::DotLine );
grid->enableYMin(true);
grid->attach( this );
/*Optimizaion for real-time data collecting*/
setAutoReplot( false );
/*Show*/
replot();
}
void CSODistance::_process()
{
ML_TRACE_IN("void CSODistance::_process()");
_outputXMarkerList->clearList();
// Delete all created CurveData objects
while ( !_outputCurveList->getCurveList().empty() ) {
ML_DELETE( _outputCurveList->getCurveList().back() );
_outputCurveList->getCurveList().pop_back();
}
if (_csoList0 != NULL) {
int nCSOs = _csoList0->numCSO();
double minDistance = 0.0;
double maxDistance = 0.0;
double avgDistance = 0.0;
double stdDevDistance = 0.0;
std::stringstream distances;
distances << _tableHeader << std::endl;
switch ( _modeFld->getEnumValue() ){
case FIRST2 :
{
if ((nCSOs >= 2) && (_csoList0->getCSOAt(0)->getIsFinished()) && (_csoList0->getCSOAt(1)->getIsFinished())) {
std::vector<vec3>pointSet1;
std::vector<vec3>pointSet2;
_csoList0->getCSOAt(0)->fillPathPointCoordinatesFlattened(pointSet1);
_csoList0->getCSOAt(1)->fillPathPointCoordinatesFlattened(pointSet2);
Vector3 minPoint1,minPoint2,maxPoint1,maxPoint2;
MinimalDistancePointClouds* pointSetsMinDist = NULL;
ML_CHECK_NEW(pointSetsMinDist, MinimalDistancePointClouds);
pointSetsMinDist->setPointSets(pointSet1, pointSet2);
pointSetsMinDist->setNumEntries(200);
pointSetsMinDist->computeDistance(minPoint1,minPoint2);
minDistance = sqrt((minPoint1[0]-minPoint2[0])*(minPoint1[0]-minPoint2[0]) +
(minPoint1[1]-minPoint2[1])*(minPoint1[1]-minPoint2[1]) +
(minPoint1[2]-minPoint2[2])*(minPoint1[2]-minPoint2[2]));
_minimumDistanceFld->setFloatValue( static_cast<float>(minDistance));
_outputXMarkerList->appendItem(XMarker( vec6(minPoint1[0],minPoint1[1],minPoint1[2],0.5f,0.0f,0.0f),
vec3(minPoint2[0]-minPoint1[0],minPoint2[1]-minPoint1[1],minPoint2[2]-minPoint1[2]),
0,""));
distances << _csoList0->getCSOAt(0)->getId() << ","
<< _csoList0->getCSOAt(1)->getId() << ","
<< minDistance << ","
<< maxDistance << ","
<< avgDistance << ","
<< stdDevDistance
<< std::endl;
} else {
_minimumDistancePoint1Fld->setVec3fValue(vec3(0.0,0.0,0.0));
_minimumDistancePoint2Fld->setVec3fValue(vec3(0.0,0.0,0.0));
_minimumDistanceFld->setFloatValue(0.0f);
_distancesFld->setStringValue( _tableHeader );
}
break;
}
case INPLANE:
case INDEX:
{
CurveData *outputCurve = new CurveData;
double *yValues = new double[ nCSOs ];
double minDist = ML_DOUBLE_MAX;
vec3 point1;
vec3 point2;
double averageMinDistance = 0.0;
double averageMeanDistance = 0.0;
double averageMaxDistance = 0.0;
for ( int iCSO = 0; iCSO<nCSOs; ++iCSO ){
CSO* currentCSO = _csoList0->getCSOAt( iCSO );
CSO* matchingCSO = _findMatchingCSO(iCSO);
if (!matchingCSO) {continue;}
std::vector<vec3>pointSet1;
std::vector<vec3>pointSet2;
currentCSO->fillPathPointCoordinatesFlattened(pointSet1);
matchingCSO->fillPathPointCoordinatesFlattened(pointSet2);
Vector3 minPoint1,minPoint2,maxPoint1,maxPoint2;
_getDistances( pointSet1, pointSet2,
minDistance,maxDistance,avgDistance,stdDevDistance,
minPoint1,minPoint2,maxPoint1,maxPoint2);
averageMinDistance += minDistance;
averageMeanDistance += avgDistance;
averageMaxDistance += maxDistance;
distances << currentCSO->getId() << ","
<< matchingCSO->getId() << ","
<< minDistance << ","
<< maxDistance << ","
<< avgDistance << ","
<< stdDevDistance
<< std::endl;
if ( minDistance < minDist ){
minDist = minDistance;
point1 = minPoint1;
point2 = minPoint2;
}
_outputXMarkerList->appendItem(XMarker( vec6(minPoint1[0],minPoint1[1],minPoint1[2],0.5f,0.0f,0.0f),
vec3(minPoint2[0]-minPoint1[0],minPoint2[1]-minPoint1[1],minPoint2[2]-minPoint1[2]),
currentCSO->getId(),""));
switch ( _curveStatistic->getEnumValue() ){
case MIN:
yValues[ iCSO ] = minDistance;
break;
case MAX:
yValues[ iCSO ] = maxDistance;
break;
case MEAN:
yValues[ iCSO ] = avgDistance;
break;
case STDEV:
yValues[ iCSO ] = stdDevDistance;
break;
default:
break;
}
} // iCSO
averageMinDistance /= (nCSOs != 0 ? nCSOs : 1.0);
averageMeanDistance /= (nCSOs != 0 ? nCSOs : 1.0);
averageMaxDistance /= (nCSOs != 0 ? nCSOs : 1.0);
outputCurve->setY( nCSOs, yValues);
delete[] yValues;
_outputCurveList->getCurveList().push_back( outputCurve );
_distancesFld->setStringValue( distances.str() );
_minimumDistancePoint1Fld->setVec3fValue(point1);
_minimumDistancePoint2Fld->setVec3fValue(point2);
_minimumDistanceFld->setFloatValue( static_cast<float>(minDistance) );
_AverageMinimumDistanceFld->setDoubleValue( averageMinDistance );
_AverageMeanDistanceFld->setDoubleValue( averageMeanDistance );
_AverageMaxDistanceFld->setDoubleValue( averageMaxDistance );
break;
}
default:
break;
}
} else {
_minimumDistancePoint1Fld->setVec3fValue(vec3(0.0,0.0,0.0));
_minimumDistancePoint2Fld->setVec3fValue(vec3(0.0,0.0,0.0));
_minimumDistanceFld->setFloatValue(0.0f);
_distancesFld->setStringValue( _tableHeader );
}
_outputXMarkerListFld->setBaseValue(_outputXMarkerList);
_outputCurveListFld->touch();
}
