#include <SpacSelector.h>
Public Slots | |
| void | inverse () |
| void | inverseAt () |
| void | radiusScroll_valueChanged () |
| void | saveSelection () |
| void | selectSamples () |
| void | setK () |
Public Member Functions | |
| bool | createObjects (AutocorrCurves *autocorr) |
| void | setMaximumSolutionCount (int c) |
| SpacSelector (QWidget *parent=0) | |
| ~SpacSelector () | |
Public Attributes | |
| CurveBrowser * | curves |
| Spac2DispOptions * | options |
Protected Member Functions | |
| virtual void | closeEvent (QCloseEvent *) |
| SpacSelector::SpacSelector | ( | QWidget * | parent = 0 | ) |
References SciFigs::GraphicSheetMenu::_childLayout, SciFigs::GraphicSheetMenu::_sheet, SciFigs::LineLayer::addLine(), curves, SciFigs::CurveBrowser::initLayer(), inverse(), inverseAt(), options, radiusScroll_valueChanged(), saveSelection(), selectSamples(), SciFigs::CurveBrowser::setCurrentLayer(), setK(), SciFigs::AbstractLine::setPen(), SciFigs::CurveBrowser::setProxy(), SciFigs::LineLayer::setReferenceLine(), SciFigs::AbstractLine::setSymbol(), and TRACE.
:
GraphicSheetMenu(parent, Qt::Window)
{
TRACE;
_lastCurRing=0;
_selAutocorr=0;
_autocorr=0;
_maxSolutionCount=5;
_childLayout->removeWidget(&_sheet);
QSplitter * hSplitter=new QSplitter(this);
hSplitter->setOrientation(Qt::Horizontal);
QSplitter * vSplitter=new QSplitter(hSplitter);
vSplitter->setOrientation(Qt::Vertical);
curves=new CurveBrowser(vSplitter);
curves->setProxy(new DispersionProxy);
AxisWindow * graph=new AxisWindow(vSplitter);
_gridLayer=new IrregularGrid2DPlot(graph);
LineLayer * dispLayer=new LineLayer(graph);
ModalLine * line=new ModalLine;
line->setPen(Pen( QColor(145,145,145), 0.6, Qt::SolidLine) );
line->setSymbol(Symbol(Symbol::Circle,1.2, Pen(QColor(222,222,222)), Brush(QColor(101,101,101), Qt::SolidPattern) ));
dispLayer->setReferenceLine(line);
curves->initLayer(dispLayer);
curves->setCurrentLayer(dispLayer);
_limitsSolutionsLayer=new LineLayer(graph);
_limitsSolutionsLayer->setReferenceLine(new PlotLine2D);
_limitsSolutionsLayer->setObjectName("SPAC Limits & Solutions");
_limitsSolutionsLayer->addLine(Pen(Qt::NoPen),Symbol(Symbol::Circle,1.2, Pen(Qt::black), Brush(Qt::black, Qt::SolidPattern)));
_limitsSolutionsLayer->addLine(Pen(Qt::black,0.6,Qt::SolidLine),Symbol());
_limitsSolutionsLayer->addLine(Pen(Qt::black,0.6,Qt::DotLine),Symbol());
hSplitter->addWidget(&_sheet);
hSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_childLayout->addWidget(hSplitter);
options=new Spac2DispOptions(this);
_childLayout->addWidget(options);
Settings::getWidget(this, "SpacSelector");
connect(options->kmin,SIGNAL(valueChanged(double)), this,SLOT(setK()));
connect(options->kmax,SIGNAL(valueChanged(double)), this,SLOT(setK()));
connect(options->vmin,SIGNAL(valueChanged(double)), this,SLOT(inverse()));
connect(options->vmax,SIGNAL(valueChanged(double)), this,SLOT(inverse()));
connect(options->nCells,SIGNAL(valueChanged(int)),
this,SLOT(inverse()));
connect(options->radiusScroll,SIGNAL(valueChanged(int)),
this,SLOT(radiusScroll_valueChanged()));
connect(options->frequencyScroll,SIGNAL(valueChanged(int)),
this,SLOT(inverseAt()));
connect(options->selectBut,SIGNAL(clicked()),
this,SLOT(selectSamples()));
connect(options->saveBut,SIGNAL(clicked()),
this,SLOT(saveSelection()));
}
| void SpacSelector::closeEvent | ( | QCloseEvent * | e | ) | [protected, virtual] |
| bool SpacSelector::createObjects | ( | AutocorrCurves * | autocorr | ) |
References SciFigs::GraphicSheetMenu::addGraph(), SciFigs::GraphicSheetMenu::addText(), QGpCoreTools::Curve< pointType >::append(), QGpGuiWave::ModalLine::curve(), QGpCoreWave::AutocorrCurves::curves(), SciFigs::GraphContentLayer::graph(), inverse(), QGpCoreWave::AutocorrRing::maxRadius(), QGpCoreWave::AutocorrRing::minRadius(), MSG_ID, options, radiusScroll_valueChanged(), QGpCoreWave::AutocorrCurves::ring(), QGpCoreWave::AutocorrCurves::ringCurves(), QGpCoreWave::AutocorrCurves::rings(), SciFigs::GraphicSheetMenu::setFrequencyTitles(), SciFigs::GraphicSheetMenu::setGraphGeometry(), setK(), SciFigs::GraphicObject::setObjectName(), SciFigs::AbstractLine::setPen(), SciFigs::Axis::setRange(), SciFigs::AbstractLine::setSymbol(), SciFigs::TextEdit::setText(), QGpCoreTools::Curve< pointType >::setValid(), QGpCoreWave::ModalFactory::setX(), QGpCoreTools::Point2D::setX(), QGpCoreTools::tr(), TRACE, w, QGpCoreTools::Rect::x1(), QGpCoreTools::Rect::x2(), SciFigs::AxisWindow::xAxis(), and SciFigs::AxisWindow::yAxis().
Referenced by main().
{
TRACE;
_autocorr=autocorr;
// Check that all ring has only one curve and is not empty
int ringCount=_autocorr->rings()->count();
for(int iRing=0; iRing<ringCount; iRing++) {
if(_autocorr->ringCurves(iRing).count()!=1) {
const AutocorrRing& ring=_autocorr->ring(iRing);
Message::critical(MSG_ID, tr("Loading Dinver target/project ..."),
tr("Ring %1 (from %2 to %3 m) contains %4 curves. Check your "
"target files with dinver so that each ring has only one curve.\n\n"
"Tip:\nStart from an empty environment, load all your target files, edit the curves "
"and choose 'Export targets' from 'File' menu.")
.arg(iRing).arg(ring.minRadius())
.arg(ring.maxRadius())
.arg(_autocorr->ringCurves(iRing).count()), Message::cancel());
return false;
}
}
AutocorrFactory autocorrFactory(_autocorr->rings());
autocorrFactory.setX(_autocorr->curves());
int omegaCount=autocorrFactory.x()->count();
if(omegaCount<2) {
Message::critical(MSG_ID, tr( "Loading Dinver target/project ..." ),
tr("No frequency samples found in target."));
return false;
}
options->radiusScroll->setMaximum(ringCount-1);
options->frequencyScroll->setMaximum(omegaCount-1);
Curve<Point2D>& resol=limitsSolutionsCurve(1);
Curve<Point2D>& aliasing=limitsSolutionsCurve(2);
Point2D fcurve;
for(int i=0;i<omegaCount;i++) {
fcurve.setX(autocorrFactory.x()->at(i));
resol.append(fcurve);
aliasing.append(fcurve);
}
double orX=0.5;
double orY=0.5;
AxisWindow * w;
Rect r;
static const QString caption(tr("Ring %1 from %2 m to %3 m"));
_spacLayers.resize(ringCount);
for(int ig=0;ig<ringCount;ig++) {
w=addGraph();
_spacLayers[ig]=new LineLayer(w);
ModalLine * line=new ModalLine;
line->setPen(Pen(Qt::NoPen));
line->setSymbol(Symbol( Symbol::Circle,1.2, Pen(Qt::gray),
Brush(Qt::gray,Qt::SolidPattern)) );
_spacLayers[ig]->setReferenceLine(line);
line=static_cast<ModalLine *>(_spacLayers[ig]->addLine());
line->curve()=_autocorr->ringCurves(ig).first();
_spacLayers[ig]->setReferenceSymbol(Symbol( Symbol::Circle, 1.2,
Pen(Qt::black),
Brush(Qt::black,Qt::SolidPattern) ));
line=static_cast<ModalLine *>(_spacLayers[ig]->addLine());
line->curve()=_autocorr->ringCurves(ig).first();
line->curve().setValid(false);
_spacLayers[ig]->setReferenceSymbol(Symbol( Symbol::Circle, 2.75,
Pen(Qt::black,0.6)) );
_spacLayers[ig]->addLine();
w->setObjectName(QString("AutocorrGraph_%1").arg(ig));
setFrequencyTitles(w,tr("Autocorr ratio"), "",Number::Fixed);
setGraphGeometry(w,orX, 9, orY+0.5, 6);
r=_spacLayers[ig]->boundingRect();
w->xAxis()->setRange(r.x1()*0.95, r.x2()*1.05);
w->yAxis()->setRange(-1.05, 1.05);
TextEdit * c=addText(orX, orY, 9, 1);
const AutocorrRing& r=_autocorr->ring(ig);
c->setText(caption.arg(ig+1).arg(r.minRadius()).arg(r.maxRadius()));
if(orX==0.5) orX=9.5; else {orX=0.5;orY+=6.5;}
}
_gridLayer->graph()->xAxis()->setRange(autocorrFactory.x()->first()*0.95, autocorrFactory.x()->last()*1.05);
// TODO: fix bug if vmin is left to 0, infinite loop after
radiusScroll_valueChanged();
inverse();
setK();
return true;
}
| void SpacSelector::inverse | ( | ) | [slot] |
References QGpCoreTools::Curve< pointType >::at(), QGpCoreWave::AutocorrCurves::curves(), SciFigs::AxisWindow::deepUpdate(), QGpGuiTools::ColorPalette::defaultColors(), QGpCoreWave::AutocorrDispersion::dispersion(), QGpCoreTools::Curve< pointType >::first(), SciFigs::GraphContentLayer::graph(), QGpCoreTools::IrregularGrid2D::indexOfY(), QGpCoreTools::IrregularGrid2D::init(), QGpCoreTools::StatisticalValue< numberType >::isValid(), QGpCoreTools::IrregularGrid2D::maximumValue(), QGpCoreTools::IrregularGrid2D::ny(), options, SciFigs::GridPlot::palette(), QGpCoreWave::AutocorrCurves::ring(), QGpCoreWave::AutocorrCurves::ringCurves(), QGpCoreWave::AutocorrCurves::rings(), QGpGuiTools::ColorPalette::setColor(), SciFigs::IrregularGrid2DPlot::setGrid(), QGpCoreTools::IrregularGrid2D::setLinear(), SciFigs::GridPlot::setPalette(), SciFigs::Axis::setRange(), QGpCoreWave::AutocorrDispersion::setRing(), QGpGuiTools::ColorPalette::setVLinear(), QGpCoreWave::ModalFactory::setX(), QGpCoreTools::IrregularGrid2D::setX(), TRACE, QGpCoreTools::IrregularGrid2D::value(), QGpCoreTools::IrregularGrid2D::valuePointer(), QGpCoreTools::StatisticalPoint< numberType >::x(), QGpCoreTools::RealStatisticalPoint::y(), QGpCoreTools::YAxis, and SciFigs::AxisWindow::yAxis().
Referenced by createObjects(), and SpacSelector().
{
TRACE;
AutocorrFactory autocorrFactory(_autocorr->rings());
autocorrFactory.setX(_autocorr->curves());
autocorrFactory.linkX(_autocorr->curves());
int ringCount=_autocorr->rings()->count();
int omegaCount=autocorrFactory.x()->count();
double smin=1.0/options->vmax->text().toDouble();
double smax=1.0/options->vmin->text().toDouble();
if(smin>=smax || smin<=0.0 || smax<=0.0) {
return;
}
int nCells=options->nCells->value();
// Get grids ready
IrregularGrid2D grid(omegaCount,nCells);
for(int i=0;i<omegaCount;i++)
grid.setX(i, autocorrFactory.x()->at(i));
grid.setLinear(YAxis,smin,smax);
grid.init(0.0);
IrregularGrid2D ringGrid;
AutocorrDispersion eng;
// Uncoupled inversion of all points
for(int ir=0;ir<ringCount;ir++) {
eng.setRing(_autocorr->ring(ir));
ringGrid.init(omegaCount,nCells,0.0);
QList<ModalCurve> ringCurves=_autocorr->ringCurves(ir);
ModalCurve& curve=ringCurves.first();
for(int iw=0;iw<omegaCount;iw++) {
double x=autocorrFactory.x()->at(iw);
FactoryPoint p=curve.at(x);
if(p.isValid() && fabs(p.y())>0.025) {
double omega=2*M_PI*autocorrFactory.x()->at(iw);
QVector<double> solutions=eng.dispersion(p, omega*smin, omega*smax);
for(int i=0; i<solutions.count() && i<_maxSolutionCount; i++) {
double s=solutions.at(i);
int is=grid.indexOfY(s);
//printf("sol @ ring %i, %lf Hz %lf --> cell %i\n", ir, autocorrFactory.x()->at(iw), 1/solutions.at(i), is);
if(s>smin && s<smax && is>-1 && is<grid.ny()) {
if(ringGrid.value(iw,is)==0) *ringGrid.valuePointer(iw,is)=1;
}
}
}
}
grid += ringGrid;
}
// Ajust palette
int maxCount=(int)grid.maximumValue();
ColorPalette pal=_gridLayer->palette();
pal.defaultColors(maxCount+2);
pal.setColor(0, Qt::white);
pal.setVLinear(0.5,maxCount+0.5);
_gridLayer->setPalette(pal);
// Set grid values
_gridLayer->setGrid (grid);
_gridLayer->graph()->yAxis()->setRange(smin*0.95,smax*1.05);
_gridLayer->graph()->deepUpdate();
}
| void SpacSelector::inverseAt | ( | ) | [slot] |
References QGpCoreTools::Curve< pointType >::append(), QGpCoreTools::Curve< pointType >::at(), SciFigs::AbstractLine::clear(), QGpCoreTools::Curve< pointType >::clear(), QGpCoreWave::AutocorrCurves::curves(), SciFigs::GraphContent::deepUpdate(), QGpCoreWave::AutocorrDispersion::dispersion(), QGpCoreTools::Curve< pointType >::first(), SciFigs::GraphContentLayer::graph(), SciFigs::AxisWindow::graphContent(), QGpCoreWave::ModalCurve::indexOf(), SciFigs::LineLayer::line(), options, QGpCoreWave::AutocorrCurves::ring(), QGpCoreWave::AutocorrCurves::ringCurves(), QGpCoreWave::AutocorrCurves::rings(), QGpCoreWave::AutocorrDispersion::setRing(), QGpCoreTools::StatisticalValue< numberType >::setStddev(), QGpCoreWave::ModalFactory::setX(), TRACE, w, and QGpCoreTools::StatisticalPoint< numberType >::x().
Referenced by radiusScroll_valueChanged(), and SpacSelector().
{
TRACE;
AutocorrFactory autocorrFactory(_autocorr->rings());
autocorrFactory.setX(_autocorr->curves());
autocorrFactory.linkX(_autocorr->curves());
int ringCount=_autocorr->rings()->count();
int omegaCount=autocorrFactory.x()->count();
double smin=1.0/options->vmax->value();
double smax=1.0/options->vmin->value();
if(smin>smax) return;
int iRing=options->radiusScroll->value();
if(iRing>ringCount-1) return;
int iFreq=options->frequencyScroll->value();
if(iFreq>omegaCount-1) return;
LineLayer * plot=_spacLayers[iRing];
AxisWindow * w=plot->graph();
LayerLocker ll(plot);
QList<ModalCurve> ringCurves=_autocorr->ringCurves(iRing);
ModalCurve& curve=ringCurves.first();
int index=curve.indexOf(iFreq); // iFreq is considered as a factory index, hence it returns -1
// if iFreq does not exist for that curve
AutocorrDispersion eng;
if(index>-1) {
FactoryPoint p=curve.at(index);
p.setStddev(0.0);
plot->line(2)->clear();
static_cast<ModalLine *>(plot->line(2))->curve().append(p);
// Inversion itself
eng.setRing(_autocorr->ring(iRing));
double omega=2*M_PI*autocorrFactory.x()->at(iFreq);
QVector<double> solutions=eng.dispersion(p, omega*smin, omega*smax);
// Plot solutions
LayerLocker ll(_limitsSolutionsLayer);
Curve<Point2D>& invRes=limitsSolutionsCurve(0);
invRes.clear();
for(int i=0; i<solutions.count() && i<_maxSolutionCount; i++) {
//printf("sol @ ring %i, %lf Hz %lf\n", iRing, autocorrFactory.x()->at(iFreq), 1/solutions.at(i));
invRes.append(Point2D( p.x(), solutions.at(i)) );
}
_gridLayer->graph()->graphContent()->deepUpdate();
w->graphContent()->deepUpdate();
}
}
| void SpacSelector::radiusScroll_valueChanged | ( | ) | [slot] |
References inverseAt(), QGpCoreWave::AutocorrRing::maxRadius(), QGpCoreWave::AutocorrRing::minRadius(), options, QGpCoreWave::AutocorrCurves::ring(), QGpCoreWave::AutocorrCurves::rings(), and TRACE.
Referenced by createObjects(), and SpacSelector().
{
TRACE;
int iRadius=options->radiusScroll->value();
if(iRadius>(int)_autocorr->rings()->count()-1) return;
// Remove marker from last ring plot
_spacLayers[_lastCurRing]->line(2)->clear();
_spacLayers[_lastCurRing]->graphContent()->deepUpdate();
options->radiusMin->setText(QString::number(_autocorr->ring(iRadius).minRadius()));
options->radiusMax->setText(QString::number(_autocorr->ring(iRadius).maxRadius()));
_lastCurRing=iRadius;
inverseAt();
}
| void SpacSelector::saveSelection | ( | ) | [slot] |
References DinverDCCore::TargetList::autocorrTarget(), fileName, MSG_ID, selectSamples(), DinverDCCore::AutocorrTarget::setCurves(), QGpCoreTools::tr(), TRACE, and QGpCoreTools::XMLHeader::xml_saveFile().
Referenced by SpacSelector().
{
TRACE;
if(!_selAutocorr) selectSamples();
if(!_selAutocorr) {
Message::warning(MSG_ID,tr("Searching dispersion limits"),
tr("You must pick 2 curves to define the dispersion\n"
"limits and to select samples."), Message::cancel());
return;
}
QString fileName=Message::getSaveFileName(tr("Save SPAC selection"),
tr("Dinver targets (*.target)"));
if(fileName.length()==0) return;
TargetList tl;
tl.autocorrTarget().setCurves( *_selAutocorr);
XMLVirtualPlugin plugin(&tl, "DispersionCurve");
XMLDinverHeader hdr(&plugin);
hdr.xml_saveFile(fileName);
}
| void SpacSelector::selectSamples | ( | ) | [slot] |
References QGpCoreWave::AutocorrCurves::addCurve(), QGpCoreWave::ModalCurve::addLog(), QGpCoreWave::AutocorrCurves::addRing(), QGpCoreTools::Curve< pointType >::append(), QGpCoreTools::Curve< pointType >::at(), SciFigs::CurveBrowser::count(), SciFigs::CurveBrowser::currentLayer(), curves, QGpCoreWave::AutocorrCurves::curves(), SciFigs::GraphContent::deepUpdate(), QGpCoreWave::AutocorrDispersion::dispersion(), QGpCoreTools::Curve< pointType >::first(), QGpCoreTools::Function, SciFigs::GraphContentLayer::graph(), SciFigs::AxisWindow::graphContent(), QGpCoreWave::ModalCurve::indexOf(), QGpCoreTools::Interpole, SciFigs::AbstractLine::isVisible(), QGpCoreTools::Curve< pointType >::last(), SciFigs::LineLayer::line(), QGpCoreTools::log(), MSG_ID, options, QGpCoreTools::Curve< pointType >::resample(), QGpCoreWave::AutocorrCurves::ring(), QGpCoreWave::AutocorrCurves::ringCurves(), QGpCoreWave::AutocorrCurves::rings(), QGpCoreTools::Curve< pointType >::setFunction(), QGpCoreWave::AutocorrDispersion::setRing(), QGpCoreTools::Curve< pointType >::setValid(), QGpCoreWave::ModalFactory::setX(), str, QGpCoreTools::tr(), TRACE, w, QGpCoreTools::StatisticalPoint< numberType >::x(), and QGpCoreTools::RealStatisticalPoint::y().
Referenced by saveSelection(), and SpacSelector().
{
TRACE;
AutocorrFactory autocorrFactory(_autocorr->rings());
autocorrFactory.setX(_autocorr->curves());
autocorrFactory.linkX(_autocorr->curves());
int ringCount=_autocorr->rings()->count();
int omegaCount=autocorrFactory.x()->count();
double kmin=options->kmin->value();
double kmax=options->kmax->value();
if(kmin>kmax) {
Message::warning(MSG_ID, tr("Selecting samples"),
tr("kmin is greater than kmax."),
Message::cancel());
return;
}
if(kmin<1e-5) {
Message::warning(MSG_ID, tr("Selecting samples"),
tr("kmin is less than 1e-5."),
Message::cancel());
return;
}
double smin=1.0/options->vmax->value();
double smax=1.0/options->vmin->value();
if(smin>smax) {
Message::warning(MSG_ID, tr("Selecting samples"),
tr("Min velocity is greater than max velocity."),
Message::cancel());
return;
}
int nCells=options->nCells->value();
int nCurves=curves->count();
// Check that only two curve are visible
const QVector<double>& freq=*autocorrFactory.x();
ModalCurve limits[2];
int nLimits=0;
for(int i=0;i<nCurves;i++) {
if(curves->currentLayer()->line(i)->isVisible()) {
if(nLimits<2) {
ModalCurve& f=static_cast<ModalLine *>(curves->currentLayer()->line(i))->curve();
// Extrapole to cover the whole frequency range
if(f.at(0).x()>freq[0]) {
f.append(FactoryPoint( freq[0], f.at(0).y()) );
f.setFunction();
}
if(f.last().x()<freq.last()) {
f.append(FactoryPoint( freq.last(), f.last().y()) );
f.setFunction();
}
limits[nLimits]=f;
nLimits++;
} else {
Message::warning(MSG_ID, tr("Selecting samples"),
tr("More than 2 curves are visible, only the first two are taken to define the slowness "
"range. Other are ignored."), Message::ok());
break;
}
}
}
if(nLimits<2) {
Message::warning(MSG_ID, tr("Selecting samples"),
tr("Less than 2 curves are visible, cannot define the slowness range. Pick at least two curves to define "
"the minimum and maximum range for dispersion curves."),
Message::cancel());
return;
}
limits[0].resample(freq, Function | Interpole);
limits[1].resample(freq, Function | Interpole);
Curve<FactoryPoint>& minS=limits[0];
Curve<FactoryPoint>& maxS=limits[1];
// Make sure that minS is always less than maxS
int iw;
for(iw=0;iw<omegaCount;iw++) {
if(minS[iw].y()>maxS[iw].y()) {
double tmp=maxS[iw].y();
maxS[iw].setY(minS[iw].y());
minS[iw].setY(tmp);
}
}
if(_selAutocorr) delete _selAutocorr;
_selAutocorr=new AutocorrCurves;
AutocorrDispersion eng;
for(int ir=0; ir<ringCount; ir++ ) {
const AutocorrRing& ring=_autocorr->ring(ir);
eng.setRing(ring);
_selAutocorr->addRing(ring);
LineLayer * plot=_spacLayers[ir];
AxisWindow * w=plot->graph();
LayerLocker ll(plot);
ModalCurve& selCurve=static_cast<ModalLine *>(plot->line(1))->curve();
selCurve.setValid(false);
QList<ModalCurve> curves=_autocorr->ringCurves(ir);
ModalCurve& curve=curves.first();
for(int iw=0;iw<omegaCount;iw++) {
int index=curve.indexOf(iw);
if(index>-1) {
const FactoryPoint& p=curve.at(index);
double omega=2*M_PI*autocorrFactory.x()->at(iw);
QVector<double> solutions=eng.dispersion(p, omega*smin, omega*smax);
for(int i=0; i<solutions.count() && i<_maxSolutionCount; i++) {
double s=solutions.at(i);
//printf("sol @ ring %i, %lf Hz %lf\n", ir, autocorrFactory.x()->at(iw), 1/s);
if(s>minS[iw].y() && s<maxS[iw].y() &&
s>smin && s<smax &&
omega*s>kmin && omega*s<kmax) {
selCurve[index].setValid(true);
break;
}
}
}
}
QString log=tr("---------------------------------------------\n"
"Samples selected using spac2disp\n\n"
"Wave number: [ %1 , %2 ] (rad/m)\n"
"Velocity: [ %3 , %4 ] (m/s)\n"
"Number of slowness cells: %5\n"
"Dispersion curve searched between:\n");
log=log.arg(kmin).arg(kmax).arg(1.0/smax).arg(1.0/smin).arg(nCells);
QString str("%1 Hz\t%2 m/s\t%3 m/s\n");
for(int iw=0;iw<omegaCount;iw++)
log+=str.arg(freq[iw]).arg(minS[iw].y()).arg(maxS[iw].y());
selCurve.addLog(log);
_selAutocorr->addCurve(selCurve);
w->graphContent()->deepUpdate();
}
//curves->curvesChanged();
}
| void SpacSelector::setK | ( | ) | [slot] |
References QGpCoreTools::Curve< pointType >::count(), SciFigs::GraphContent::deepUpdate(), SciFigs::GraphContentLayer::graph(), SciFigs::AxisWindow::graphContent(), options, and TRACE.
Referenced by createObjects(), and SpacSelector().
{
TRACE;
double kmin=options->kmin->value();
double kmax=options->kmax->value();
LayerLocker ll(_limitsSolutionsLayer);
double invWLmin=kmin/(2*M_PI);
double invWLmax=kmax/(2*M_PI);
Curve<Point2D>& resol=limitsSolutionsCurve(1);
Curve<Point2D>& aliasing=limitsSolutionsCurve(2);
for(int i=0;i<resol.count();i++) {
resol[i].setY(invWLmin/resol[i].x());
aliasing[i].setY(invWLmax/aliasing[i].x());
}
_gridLayer->graph()->graphContent()->deepUpdate();
}
| void SpacSelector::setMaximumSolutionCount | ( | int | c | ) | [inline] |
Referenced by main().
{_maxSolutionCount=c;}
Referenced by selectSamples(), and SpacSelector().
Referenced by createObjects(), inverse(), inverseAt(), radiusScroll_valueChanged(), selectSamples(), setK(), and SpacSelector().
