TDV_NAMESPACE_BEGIN
bool ImageReader::update()
{
WriteGuard<ReadWritePipe<CvMat*> > wg(m_wpipe);
if ( m_cImg < m_filenames.size() )
{
const std::string &filename(m_filenames[m_cImg++]);
IplImage *img = cvLoadImage(filename.c_str());
if ( img != NULL )
{
#if 0
CvMat *mat = cvCreateMatHeader(img->height, img->width, CV_8UC3);
mat = cvGetMat(img, mat);
#else
CvMat *mat = cvCreateMat(img->height, img->width, CV_8UC3);
cvConvertImage(img, mat, CV_CVTIMG_SWAP_RB);
cvReleaseImage(&img);
#endif
wg.write(mat);
}
else
{
throw Exception(boost::format("can't open image: %1%")
% filename);
}
}
return wg.wasWrite();
}
WalletGroup BlockDataViewer::getStandAloneWalletGroup(
const vector<BinaryData>& wltIDs, HistoryOrdering order)
{
WalletGroup wg(this, this->saf_);
wg.order_ = order;
auto wallets = groups_[group_wallet].getWalletMap();
auto lockboxes = groups_[group_lockbox].getWalletMap();
for (const auto& wltid : wltIDs)
{
auto wltIter = wallets.find(wltid);
if (wltIter != wallets.end())
{
wg.wallets_[wltid] = wltIter->second;
}
else
{
auto lbIter = lockboxes.find(wltid);
if (lbIter != lockboxes.end())
{
wg.wallets_[wltid] = lbIter->second;
}
}
}
wg.pageHistory(true, false);
return wg;
}
void test_smspec_completion() {
std::string kw( "CWIT" );
std::string wg( "WELL1" );
int dims[ 3 ] = { 10, 10, 10 };
int ijk[ 3 ] = { 1, 1, 1 };
ERT::smspec_node completion( kw, wg, dims, ijk );
test_assert_true( completion.keyword() == kw );
test_assert_true( completion.type() == ECL_SMSPEC_COMPLETION_VAR );
test_assert_true( completion.num() == 112 );
}
void test_smspec_wg() {
std::string kw( "WWCT" );
std::string wg( "OP1" );
std::string gr( "WG1" );
ERT::smspec_node well( ECL_SMSPEC_WELL_VAR, wg, kw );
ERT::smspec_node group( ECL_SMSPEC_GROUP_VAR, gr, kw );
test_assert_true(well.wgname() == wg);
test_assert_true(well.type() == ECL_SMSPEC_WELL_VAR );
test_assert_true(group.wgname() == gr);
test_assert_true(group.type() == ECL_SMSPEC_GROUP_VAR );
}
void test_smspec_wg() {
std::string wkw( "WWCT" );
std::string gkw( "GWCT" );
std::string wg( "OP1" );
std::string gr( "WG1" );
ERT::smspec_node well( ECL_SMSPEC_WELL_VAR, wg, wkw );
ERT::smspec_node group( ECL_SMSPEC_GROUP_VAR, gr, gkw );
test_assert_string_equal(well.key1() , "WWCT:OP1");
test_assert_string_equal(well.keyword() , "WWCT");
test_assert_true(well.wgname() == wg);
test_assert_true(well.type() == ECL_SMSPEC_WELL_VAR );
test_assert_string_equal(group.key1(), "GWCT:WG1");
test_assert_string_equal(group.keyword() , "GWCT");
test_assert_true(group.wgname() == gr);
test_assert_true(group.type() == ECL_SMSPEC_GROUP_VAR );
}
void WargearList::fromXml(const QDomElement& ele) throw(XmlParseException)
{
QDomNodeList list = ele.childNodes();
int len = list.length();
QDomElement current;
for(int i = 0; i < len; i++)
{
current = list.item(i).toElement();
if(!current.isNull())
{
if(current.nodeName() == "wargear")
{
Wargear wg(current, race());
m_wargears.insert(wg.id(), wg);
}
else
throw XmlParseException("invalid wargear list node", current);
}
}
}
void TestMRPPWindow::resized()
{
if (m_controls.size() == 0)
return;
auto sz = getSize();
int w = sz.getWidth();
int h = sz.getHeight();
int gdivs = 16;
MRP::Rectangle wg(0, 0, w, h);
for (int i = 0; i < 8; ++i)
{
m_controls[i]->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 0, i, 1, i + 1));
}
m_slider1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 1, 0, 16, 1));
m_envcontrol1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 1, 1, 16, 10));
m_zoomscroll1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 1, 10, 16, 11));
m_edit1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 0, 11, 16, 12));
//m_combo1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 0, 15, 7, 16));
//m_combo2->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 8, 15, 16, 16));
m_progressbar1->setBounds(MRP::Rectangle::fromGridPositions(wg, gdivs, 0, 15, 16, 16));
}
/**
* @brief Computes weights of an inverted file structure
*
* @param ifindex Inverted file index
* @param corpus Corpus
* @param wg Function to compute weight
*/
void ifindex_weight(ListDB *ifindex, ListDB *corpus, double (*wg)(uint,uint,uint,uint,uint,uint))
{
uint i, j;
// Computes size of documents
uint *docsizes = (uint *) calloc(corpus->size, sizeof(uint));
for (i = 0; i < corpus->size; i++)
for (j = 0; j < corpus->lists[i].size; j++)
docsizes[i] += corpus->lists[i].data[j].freq;
// performs term weighting
for (i = 0; i < ifindex->size; i++) {
for (j = 0; j < ifindex->lists[i].size; j++) {
double wval = wg(ifindex->lists[i].data[j].freq, ifindex->lists[i].size,
docsizes[ifindex->lists[i].data[j].item],
corpus->lists[ifindex->lists[i].data[j].item].size,
corpus->size, ifindex->size);
ifindex->lists[i].data[j].freq = weights_intweight(wval);
if (ifindex->lists[i].data[j].freq == 0)
ifindex->lists[i].data[j].freq = 1;
}
}
}
WalletGroup BlockDataViewer::getStandAloneWalletGroup(
const vector<BinaryData>& wltIDs, HistoryOrdering order)
{
checkBDMisReady();
WalletGroup wg(this, this->saf_);
wg.order_ = order;
auto wallets = groups_[group_wallet].getWalletMap();
auto lockboxes = groups_[group_lockbox].getWalletMap();
for (const auto& wltid : wltIDs)
{
auto wltIter = wallets.find(wltid);
if (wltIter != wallets.end())
{
shared_ptr<BtcWallet> wltCopy(
new BtcWallet(*(wltIter->second.get())));
wg.wallets_[wltid] = wltCopy;
}
else
{
auto lbIter = lockboxes.find(wltid);
if (lbIter != lockboxes.end())
{
shared_ptr<BtcWallet> lbCopy(
new BtcWallet(*(lbIter->second.get())));
wg.wallets_[wltid] = lbCopy;
}
}
}
wg.pageHistory(true);
return wg;
}
QList<QWizardPage*> SeekThru::GetWizardPages () const
{
std::auto_ptr<WizardGenerator> wg (new WizardGenerator);
return wg->GetPages ();
}
void prim_conv11::operator()
(
signal_& quality__io,
signal_& wiregroup__io,
signal_& hstrip__io,
signal_& clctpat__io,
signal_& ph__io,
signal_& th__io,
signal_& vl__io,
signal_& phzvl__io,
signal_& me11a__io,
signal_& clctpat_r__io,
signal_& ph_hit__io,
signal_& th_hit__io,
signal_& sel__io,
signal_& addr__io,
signal_& r_in__io,
signal_& r_out__io,
signal_& we__io,
signal_& clk__io,
signal_& control_clk__io
)
{
if (!built)
{
seg_ch = 2;
bw_ph = 8;
bw_th = 7;
bw_fph = 12;
bw_fth = 8;
bw_wg = 7;
bw_ds = 7;
bw_hs = 8;
pat_w_st3 = 3;
pat_w_st1 = pat_w_st3 + 1;
full_pat_w_st3 = (1 << (pat_w_st3+1)) - 1;
full_pat_w_st1 = (1 << (pat_w_st1+1)) - 1;
padding_w_st1 = full_pat_w_st1 / 2;
padding_w_st3 = full_pat_w_st3 / 2;
red_pat_w_st3 = pat_w_st3 * 2 + 1;
red_pat_w_st1 = pat_w_st1 * 2 + 1;
fold = 4;
th_ch11 = seg_ch*seg_ch;
bw_q = 4;
bw_addr = 7;
ph_raw_w = (1 << pat_w_st3) * 15;
th_raw_w = (1 << bw_th);
max_drift = 3;
bw_phi = 12;
bw_eta = 7;
ph_hit_w = 40+4;
ph_hit_w20 = ph_hit_w;
ph_hit_w10 = 20+4;
th_hit_w = 56 + 8;
endcap = 1;
n_strips = (station <= 1 && cscid <= 2) ? 64 :
(station <= 1 && cscid >= 6) ? 64 : 80;
n_wg = (station <= 1 && cscid <= 3) ? 48 :
(station <= 1 && cscid >= 6) ? 32 :
(station == 2 && cscid <= 3) ? 112 :
(station >= 3 && cscid <= 3) ? 96 : 64;
th_coverage = (station <= 1 && cscid <= 2) ? 45 :
(station <= 1 && cscid >= 6) ? 27 :
(station <= 1 && cscid >= 3) ? 39 :
(station == 2 && cscid <= 2) ? 43 :
(station == 2 && cscid >= 3) ? 56 :
(station == 3 && cscid <= 2) ? 34 :
(station == 3 && cscid >= 3) ? 52 :
(station == 4 && cscid <= 2) ? 28 :
(station == 4 && cscid >= 3) ? 50 : 0;
ph_coverage = (station <= 1 && cscid >= 6) ? 15 : //30 :
(station >= 2 && cscid <= 2) ? 40 : 20;
th_ch = (station <= 1 && cscid <= 2) ? (seg_ch*seg_ch) : seg_ch;
ph_reverse = (endcap == 1 && station >= 3) ? 1 :
(endcap == 2 && station < 3) ? 1 : 0;
th_mem_sz = (1 << bw_addr);
th_corr_mem_sz = (1 << bw_addr);
mult_bw = bw_fph + 11;
ph_zone_bnd1 = (station <= 1 && cscid <= 2) ? 41 :
(station == 2 && cscid <= 2) ? 41 :
(station == 2 && cscid > 2) ? 87 :
(station == 3 && cscid > 2) ? 49 :
(station == 4 && cscid > 2) ? 49 : 127;
ph_zone_bnd2 = (station == 3 && cscid > 2) ? 87 : 127;
zone_overlap = 2;
bwr = 6;
bpow = 6;
cnr = (1 << bpow);
cnrex = ph_raw_w;
build();
// input parameters from MPC
quality.attach(quality__io);
wiregroup.attach(wiregroup__io);
hstrip.attach(hstrip__io);
clctpat.attach(clctpat__io);
sel.attach(sel__io);
addr.attach(addr__io);
r_in.attach(r_in__io);
we.attach(we__io);
clk.attach(clk__io);
control_clk.attach(control_clk__io);
// outputs
// low-precision ph, only for detection
// high-precision ph with displacement correction will be calculated when
// 3 best tracks are found.
ph.attach(ph__io);
// full precision th, but without displacement correction, takes th duplication into account
th.attach(th__io);
// one-bit valid flags
vl.attach(vl__io);
phzvl.attach(phzvl__io);
me11a.attach(me11a__io);
clctpat_r.attach(clctpat_r__io);
// ph and th raw hits
ph_hit.attach(ph_hit__io);
th_hit.attach(th_hit__io);
r_out.attach(r_out__io);
}
pc_id(3,0) = cscid;
pc_id(7,4) = station;
r_out = (sel == const_(2, 0x0UL)) ? params[addr] :
(sel == const_(2, 0x1UL)) ? th_mem[addr] :
(sel == const_(2, 0x2UL)) ? th_corr_mem[addr] : pc_id;
beginalways();
if (posedge (control_clk))
{
if (( (sel) == 0)) { { if (we) params [addr] = r_in; } } else
if (( (sel) == 1)) { { if (we) th_mem [addr] = r_in; } } else
if (( (sel) == 2)) { { if (we) th_corr_mem[addr] = r_in(3,0); } }
}
endalways();
beginalways();
if (posedge (clk))
{
// zero outputs
vl = 0;
phzvl = 0;
for (i = 0; i < seg_ch; i = i+1) { fph[i] = 0; clctpat_r[i] = 0; }
for (i = 0; i < th_ch; i = i+1) th[i] = 0;
ph_hit = 0;
th_hit = 0;
for (i = 0; i < seg_ch; i = i+1)
{
factor[i] = (station <= 1 && cscid <= 2 && hstrip[i] > 127) ? 1707 : // ME1/1a
1301; // ME1/1b
//if(factor[i])
// std::cout<<"factor 11 = "<<factor[i]<<std::endl;
me11a_w[i] = (station <= 1 && cscid <= 2 && hstrip[i] > 127);
if (( (clctpat[i]) == 0)) { { clct_pat_corr = const_(3, 0x0UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 1)) { { clct_pat_corr = const_(3, 0x0UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 2)) { { clct_pat_corr = const_(3, 0x5UL); clct_pat_sign = 1; } } else
if (( (clctpat[i]) == 3)) { { clct_pat_corr = const_(3, 0x5UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 4)) { { clct_pat_corr = const_(3, 0x5UL); clct_pat_sign = 1; } } else
if (( (clctpat[i]) == 5)) { { clct_pat_corr = const_(3, 0x5UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 6)) { { clct_pat_corr = const_(3, 0x2UL); clct_pat_sign = 1; } } else
if (( (clctpat[i]) == 7)) { { clct_pat_corr = const_(3, 0x2UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 8)) { { clct_pat_corr = const_(3, 0x2UL); clct_pat_sign = 1; } } else
if (( (clctpat[i]) == 9)) { { clct_pat_corr = const_(3, 0x2UL); clct_pat_sign = 0; } } else
if (( (clctpat[i]) == 10)) { { clct_pat_corr = const_(3, 0x0UL); clct_pat_sign = 0; } } else { { clct_pat_corr = const_(3, 0x0UL); clct_pat_sign = 0; } }
// reverse clct pattern correction if chamber is reversed
// if (ph_reverse) clct_pat_sign = ~clct_pat_sign;
// convert into 1/8 strips and remove ME1/1a offset (512=128*4)
eight_str[i] = (const_s(2, 0x0UL), hstrip [i], const_s(2, 0x0UL)) - (me11a_w[i] ? 512 : 0);
// clct pattern correction
if (clct_pat_sign == 0) eight_str[i] = eight_str[i] + clct_pat_corr(2,1);
else eight_str[i] = eight_str[i] - clct_pat_corr(2,1);
if (quality[i])
{
vl[i] = 1;
// ph conversion
// for factors 1024 and 2048 the multiplier should be replaced with shifts by synthesizer
mult = eight_str[i] * factor[i];
ph_tmp = mult(mult_bw-1 , 10);
//std::cout<<"ph_tmp = "<<ph_tmp<<std::endl;
ph_init_ix = me11a_w[i] ? const_(3, 2UL) : const_(3, 0UL); // index of ph_init parameter to apply (different for ME11a and b)
//std::cout<<"ph_init_ix = "<<ph_init_ix<<std::endl;
if (ph_reverse)
{
fph[i] = params[ph_init_ix] - ph_tmp;
// set ph raw hits
ph_hit[ph_coverage - ph_tmp(bw_fph-1,5) + params[ph_init_ix + const_(3, 1UL)](7,1)] = 1;
}
else
{
fph[i] = params[ph_init_ix] + ph_tmp;
// set ph raw hits
ph_hit[ph_tmp(bw_fph-1,5) + params[ph_init_ix + const_(3, 1UL)](7,1)] = 1;
/* -----\/----- EXCLUDED -----\/-----
// add hits to take ME11a strip ganging into account
// offsets of 14 and 28 is what I observe from MC. Calculations show 11.6 and 23.2 (???)
if (me11a_w[i])
{
ph_hit[ph_tmp(bw_fph-1,5) + params[2] + 14] = 1;
ph_hit[ph_tmp(bw_fph-1,5) + params[2] + 28] = 1;
}
-----/\----- EXCLUDED -----/\----- */
}
//std::cout<<"estr = "<<eight_str[i]<<", factor = "<<factor[i]<<", ph_rev = "<<ph_reverse<<", ph_tmp = "<<ph_tmp<<std::endl;
//std::cout<<"ph_hit = "<<ph_tmp(bw_fph-1,5) + params[ph_init_ix + const_(3, 1UL)](7,1)<<std::endl;
//std::cout<<"strip = "<<hstrip[i]<<", Id = "<<cscid + 1<<",phinit = "<<(params[ph_init_ix])<<"ph_cov = "<<ph_coverage<<", and phshift = "<<(ph_tmp(bw_fph-1,5))<<", and phdisp = "<<(params[ph_init_ix + const_(3, 1UL)](7,1))<<"\n\n\n";
wg = wiregroup[i];
// th conversion
// call appropriate LUT, it returns th[i] relative to wg0 of that chamber
th_orig = th_mem[wg];
//std::cout<<"wire = "<<wg<<", th_mem[wg] = "<<th_orig<<std::endl;
// need th duplication here
for (j = 0; j < seg_ch; j = j+1)
{
if (quality[j])
{
// calculate correction for each strip number
// index is: (wiregroup(2 MS bits), dblstrip(5-bit for these chambers))
index = (wg(5,4), eight_str[j](8,4));
th_corr = th_corr_mem[index];
//std::cout<<"eightstrip = "<<eight_str[j]<<", eightstrip(8,4) = "<<eight_str[j](8,4)<<", index = "<<index<<", th_corr = "<<th_corr<<std::endl;
//std::cout<<"th_corr = "<<th_corr<<" and th_orig = "<<th_orig<<std::endl;
// apply correction to the corresponding output
if (ph_reverse) th_tmp = (th_orig - th_corr) & const_(6, 0x3fUL);
else th_tmp = (th_orig + th_corr) & const_(6, 0x3fUL);
//std::cout<<"ph_reverse = "<<ph_reverse<<" ";
//if(th_tmp)std::cout<<"th_tmp = "<<th_tmp<<" and thcoverage = "<<th_coverage<<std::endl;
// check that correction did not make invalid value outside chamber coverage
// this will actually take care of both positive and negative illegal values
if (th_tmp < th_coverage)
{
// apply initial th value for that chamber
th[i*seg_ch+j] = th_tmp + params[4];
//std::cout<<"params[4] = "<<params[4]<<"\n";
// th hits
th_hit[th_tmp + params[5]] = 1;
// check which zones ph hits should be applied to
if (th[i*seg_ch+j] <= (ph_zone_bnd1 + zone_overlap)) phzvl[0] = 1;
if (th[i*seg_ch+j] > (ph_zone_bnd2 - zone_overlap)) phzvl[2] = 1;
if (
(th[i*seg_ch+j] > (ph_zone_bnd1 - zone_overlap)) &&
(th[i*seg_ch+j] <= (ph_zone_bnd2 + zone_overlap))
) phzvl[1] = 1;
//std::cout<<"ph_zone_bnd1 = "<<ph_zone_bnd1<<std::endl;
//std::cout<<"phzvl = "<<phzvl<<std::endl;
}
}
}
clctpat_r[i] = clctpat[i]; // just propagate pattern downstream
} // if (quality[i])
ph[i] = fph[i];
//if(fph[i]) std::cout<<"fph["<<i<<"] = "<<fph[i]<<" and vl[i] = "<<vl[i]<<std::endl;
} // for (i = 0; i < seg_ch; i = i+1)
me11a = me11a_w;
}
endalways();
}
ASMmxBase::VolumeVec ASMmxBase::establishBases(Go::SplineVolume* svol,
MixedType type)
{
VolumeVec result(2);
// With mixed methods we need two separate spline spaces
if (type == FULL_CONT_RAISE_BASIS1 || type == FULL_CONT_RAISE_BASIS2)
{
// basis1 should be one degree higher than basis2 and C^p-1 continuous
int ndim = svol->dimension();
Go::BsplineBasis b1 = svol->basis(0).extendedBasis(svol->order(0)+1);
Go::BsplineBasis b2 = svol->basis(1).extendedBasis(svol->order(1)+1);
Go::BsplineBasis b3 = svol->basis(2).extendedBasis(svol->order(2)+1);
/* To lower order and regularity this can be used instead
std::vector<double>::const_iterator first = ++surf->basis(0).begin();
std::vector<double>::const_iterator last = --surf->basis(0).end();
Go::BsplineBasis b1 = Go::BsplineBasis(surf->order_u()-1,first,last);
first = ++surf->basis(1).begin();
last = --surf->basis(1).end();
Go::BsplineBasis b2 = Go::BsplineBasis(surf->order_v()-1,first,last);
*/
// Compute parameter values of the Greville points
size_t i;
RealArray ug(b1.numCoefs()), vg(b2.numCoefs()), wg(b3.numCoefs());
for (i = 0; i < ug.size(); i++)
ug[i] = b1.grevilleParameter(i);
for (i = 0; i < vg.size(); i++)
vg[i] = b2.grevilleParameter(i);
for (i = 0; i < wg.size(); i++)
wg[i] = b3.grevilleParameter(i);
if (svol->rational()) {
std::vector<double> rCoefs(svol->rcoefs_begin(), svol->rcoefs_end());
// we normally would set coefs as (x*w, y*w, w)
// however, gotools use this representation internally already.
// instance a Bspline surface in ndim+1
Go::SplineVolume vol2(svol->basis(0), svol->basis(1), svol->basis(2), rCoefs.begin(), ndim+1, false);
// interpolate the Bspline surface onto new basis
RealArray XYZ((ndim+1)*ug.size()*vg.size()*wg.size());
vol2.gridEvaluator(XYZ,ug,vg,wg);
std::unique_ptr<Go::SplineVolume> svol3(Go::VolumeInterpolator::regularInterpolation(b1,b2,b3,ug,vg,wg,XYZ,ndim+1,false,XYZ));
// new rational coefs are (x/w', y/w', w')
// apparently gotools will rescale coeffs on surface creation.
result[0].reset(new Go::SplineVolume(svol3->basis(0), svol3->basis(1), svol3->basis(2), svol3->coefs_begin(), ndim, true));
} else {
RealArray XYZ(ndim*ug.size()*vg.size()*wg.size());
// Evaluate the spline surface at all points
svol->gridEvaluator(ug,vg,wg,XYZ);
// Project the coordinates onto the new basis (the 2nd XYZ is dummy here)
result[0].reset(Go::VolumeInterpolator::regularInterpolation(b1,b2,b3,
ug,vg,wg,XYZ,ndim,
false,XYZ));
}
result[1].reset(new Go::SplineVolume(*svol));
}
else if (type == REDUCED_CONT_RAISE_BASIS1 || type == REDUCED_CONT_RAISE_BASIS2)
{
// Order-elevate basis1 such that it is of one degree higher than basis2
// but only C^p-2 continuous
result[0].reset(new Go::SplineVolume(*svol));
result[0]->raiseOrder(1,1,1);
result[1].reset(new Go::SplineVolume(*svol));
}
else if (ASMmxBase::Type == ASMmxBase::DIV_COMPATIBLE)
{
result.resize(4);
// basis1 should be one degree higher than basis2 and C^p-1 continuous
int ndim = svol->dimension();
Go::BsplineBasis a1 = svol->basis(0);
Go::BsplineBasis a2 = svol->basis(1);
Go::BsplineBasis a3 = svol->basis(2);
Go::BsplineBasis b1 = svol->basis(0).extendedBasis(svol->order(0)+1);
Go::BsplineBasis b2 = svol->basis(1).extendedBasis(svol->order(1)+1);
Go::BsplineBasis b3 = svol->basis(2).extendedBasis(svol->order(2)+1);
// Compute parameter values of the Greville points
size_t i;
RealArray u0(a1.numCoefs()), v0(a2.numCoefs()), w0(a3.numCoefs());
for (i = 0; i < u0.size(); i++)
u0[i] = a1.grevilleParameter(i);
for (i = 0; i < v0.size(); i++)
v0[i] = a2.grevilleParameter(i);
for (i = 0; i < w0.size(); i++)
w0[i] = a3.grevilleParameter(i);
RealArray ug(b1.numCoefs()), vg(b2.numCoefs()), wg(b3.numCoefs());
for (i = 0; i < ug.size(); i++)
ug[i] = b1.grevilleParameter(i);
for (i = 0; i < vg.size(); i++)
vg[i] = b2.grevilleParameter(i);
for (i = 0; i < wg.size(); i++)
wg[i] = b3.grevilleParameter(i);
// Evaluate the spline surface at all points
// Project the coordinates onto the new basis (the 2nd XYZ is dummy here)
RealArray XYZ0(ndim*ug.size()*v0.size()*w0.size()), XYZ1(ndim*u0.size()*vg.size()*w0.size()), XYZ2(ndim*u0.size()*v0.size()*wg.size());
svol->gridEvaluator(ug,v0,w0,XYZ0);
svol->gridEvaluator(u0,vg,w0,XYZ1);
svol->gridEvaluator(u0,v0,wg,XYZ2);
result[0].reset(Go::VolumeInterpolator::regularInterpolation(b1,a2,a3,
ug,v0,w0,XYZ0,ndim,
false,XYZ0));
result[1].reset(Go::VolumeInterpolator::regularInterpolation(a1,b2,a3,
u0,vg,w0,XYZ1,ndim,
false,XYZ1));
result[2].reset(Go::VolumeInterpolator::regularInterpolation(a1,a2,b3,
u0,v0,wg,XYZ2,ndim,
false,XYZ2));
result[3].reset(new Go::SplineVolume(*svol));
geoBasis = 4;
}
if (type == FULL_CONT_RAISE_BASIS2 || type == REDUCED_CONT_RAISE_BASIS2)
std::swap(result[0], result[1]);
return result;
}
