void c_xy2fxfy(float *fx, float *fy, float x, float y)
{
int ix;
int iy;
int un = 1;
float x_x, y_y;
x_x = x;
y_y = y;
switch (usSpace.mapping)
{
case 5:
*fx = x;
f77name(ez_rgdint_1_nw)(fy,&x_x,&y_y, &un, usSpace.z, &usSpace.ni,&un, &usSpace.nj);
break;
case 6:
f77name(ez_rgdint_1_nw)(fx,&x_x,&y_y, &un, usSpace.zx, &usSpace.ni,&un, &usSpace.nj);
f77name(ez_rgdint_1_nw)(fy,&x_x,&y_y, &un, usSpace.zy, &usSpace.ni,&un, &usSpace.nj);
break;
default:
if (usSpace.axex)
{
INTERP(*fx, x, usSpace.axex, usSpace.ni)
}
else
{
*fx = x_x;
}
if (usSpace.axey)
{
INTERP(*fy, y_y, usSpace.axey, usSpace.nj)
}
else
{
*fy = y_y;
}
break;
}
}
/* Function: rt_Lookup2D_Normal ==============================================
* Abstract:
* 2D normal lookup routine for data type of real_T
*/
real_T rt_Lookup2D_Normal (const real_T *xVals, const int_T numX,
const real_T *yVals, const int_T numY,
const real_T *zVals,
const real_T x, const real_T y)
{
int_T xIdx, yIdx;
real_T ylo, yhi;
real_T Zx0yhi, Zx0ylo, xlo, xhi;
real_T corner1, corner2;
xIdx = rt_GetLookupIndex(xVals,numX,x);
xlo = xVals[xIdx];
xhi = xVals[xIdx+1];
yIdx = rt_GetLookupIndex(yVals,numY,y);
ylo = yVals[yIdx];
yhi = yVals[yIdx+1];
corner1 = *(zVals + xIdx + (numX * yIdx));
corner2 = *(zVals + (xIdx+1) + (numX * yIdx));
Zx0ylo = INTERP(x, xlo, xhi, corner1, corner2);
corner1 = *(zVals + xIdx + (numX * (yIdx+1)));
corner2 = *(zVals + (xIdx+1) + (numX*(yIdx+1)));
Zx0yhi = INTERP(x, xlo, xhi, corner1, corner2);
return (INTERP(y,ylo,yhi,Zx0ylo,Zx0yhi));
}
static av_always_inline void filter_rgb(FadeContext *s, const AVFrame *frame,
int slice_start, int slice_end,
int do_alpha, int step)
{
int i, j;
const uint8_t r_idx = s->rgba_map[R];
const uint8_t g_idx = s->rgba_map[G];
const uint8_t b_idx = s->rgba_map[B];
const uint8_t a_idx = s->rgba_map[A];
const uint8_t *c = s->color_rgba;
for (i = slice_start; i < slice_end; i++) {
uint8_t *p = frame->data[0] + i * frame->linesize[0];
for (j = 0; j < frame->width; j++) {
#define INTERP(c_name, c_idx) av_clip_uint8(((c[c_idx]<<16) + ((int)p[c_name] - (int)c[c_idx]) * s->factor + (1<<15)) >> 16)
p[r_idx] = INTERP(r_idx, 0);
p[g_idx] = INTERP(g_idx, 1);
p[b_idx] = INTERP(b_idx, 2);
if (do_alpha)
p[a_idx] = INTERP(a_idx, 3);
p += step;
}
}
}
/* all cpi and result must be aligned (have the same number of xforms,
and have final xform in the same slot) */
void flam3_interpolate_n(flam3_genome *result, int ncp,
flam3_genome *cpi, double *c, double stagger) {
int i, j, k, numstd;
if (flam3_palette_interpolation_hsv == cpi[0].palette_interpolation) {
for (i = 0; i < 256; i++) {
double t[3], s[4];
s[0] = s[1] = s[2] = s[3] = s[4] = 0.0;
for (k = 0; k < ncp; k++) {
rgb2hsv(cpi[k].palette[i].color, t);
for (j = 0; j < 3; j++)
s[j] += c[k] * t[j];
s[3] += c[k] * cpi[k].palette[i].color[3];
s[4] += c[k] * cpi[k].palette[i].index;
}
hsv2rgb(s, result->palette[i].color);
result->palette[i].color[3] = s[3];
result->palette[i].index = s[4];
for (j = 0; j < 4; j++) {
if (result->palette[i].color[j] < 0.0)
result->palette[i].color[j] = 0.0;
if (result->palette[i].color[j] > 1.0)
result->palette[i].color[j] = 1.0;
}
if (result->palette[i].index < 0.0)
result->palette[i].index = 0.0;
if (result->palette[i].index > 255.0)
result->palette[i].index = 255.0;
}
} else {
/* Sweep - not the best option for float indices */
for (i = 0; i < 256; i++) {
j = (i < (256 * c[0])) ? 0 : 1;
result->palette[i] = cpi[j].palette[i];
}
}
result->palette_index = flam3_palette_random;
result->symmetry = 0;
result->spatial_filter_select = cpi[0].spatial_filter_select;
result->temporal_filter_type = cpi[0].temporal_filter_type;
result->palette_mode = cpi[0].palette_mode;
result->interpolation_type = cpi[0].interpolation_type;
INTERP(brightness);
INTERP(contrast);
INTERP(highlight_power);
INTERP(gamma);
INTERP(vibrancy);
INTERP(hue_rotation);
INTERI(width);
INTERI(height);
INTERI(spatial_oversample);
INTERP(center[0]);
INTERP(center[1]);
INTERP(rot_center[0]);
INTERP(rot_center[1]);
INTERP(background[0]);
INTERP(background[1]);
INTERP(background[2]);
INTERP(pixels_per_unit);
INTERP(spatial_filter_radius);
INTERP(temporal_filter_exp);
INTERP(temporal_filter_width);
INTERP(sample_density);
INTERP(zoom);
INTERP(rotate);
INTERI(nbatches);
INTERI(ntemporal_samples);
INTERP(estimator);
INTERP(estimator_minimum);
INTERP(estimator_curve);
INTERP(gam_lin_thresh);
/* Interpolate the chaos array */
numstd = cpi[0].num_xforms - (cpi[0].final_xform_index >= 0);
for (i=0;i<numstd;i++) {
for (j=0;j<numstd;j++) {
INTERP(chaos[i][j]);
if (result->chaos[i][j]<0) result->chaos[i][j]=0;
//chaos can be > 1
//if (result->chaos[i][j]>1) result->chaos[i][j]=1.0;
}
}
/* Interpolate each xform */
for (i = 0; i < cpi[0].num_xforms; i++) {
double csave[2];
double td;
int all_id;
int nx = cpi[0].num_xforms-(cpi[0].final_xform_index>=0);
if (ncp==2 && stagger>0 && i!=cpi[0].final_xform_index) {
csave[0] = c[0];
csave[1] = c[1];
c[0] = get_stagger_coef(csave[0],stagger,nx,i);
c[1] = 1.0-c[0];
}
INTERP(xform[i].density);
td = result->xform[i].density;
result->xform[i].density = (td < 0.0) ? 0.0 : td;
INTERP(xform[i].color);
if (result->xform[i].color<0) result->xform[i].color=0;
if (result->xform[i].color>1) result->xform[i].color=1;
INTERP(xform[i].opacity);
INTERP(xform[i].color_speed);
INTERP(xform[i].animate);
INTERP(xform[i].blob_low);
INTERP(xform[i].blob_high);
INTERP(xform[i].blob_waves);
INTERP(xform[i].pdj_a);
INTERP(xform[i].pdj_b);
INTERP(xform[i].pdj_c);
INTERP(xform[i].pdj_d);
INTERP(xform[i].fan2_x);
INTERP(xform[i].fan2_y);
INTERP(xform[i].rings2_val);
INTERP(xform[i].perspective_angle);
INTERP(xform[i].perspective_dist);
INTERP(xform[i].julian_power);
INTERP(xform[i].julian_dist);
INTERP(xform[i].juliascope_power);
INTERP(xform[i].juliascope_dist);
INTERP(xform[i].radial_blur_angle);
INTERP(xform[i].pie_slices);
INTERP(xform[i].pie_rotation);
INTERP(xform[i].pie_thickness);
INTERP(xform[i].ngon_sides);
INTERP(xform[i].ngon_power);
INTERP(xform[i].ngon_circle);
INTERP(xform[i].ngon_corners);
INTERP(xform[i].curl_c1);
INTERP(xform[i].curl_c2);
INTERP(xform[i].rectangles_x);
INTERP(xform[i].rectangles_y);
INTERP(xform[i].amw_amp);
INTERP(xform[i].disc2_rot);
INTERP(xform[i].disc2_twist);
INTERP(xform[i].super_shape_rnd);
INTERP(xform[i].super_shape_m);
INTERP(xform[i].super_shape_n1);
INTERP(xform[i].super_shape_n2);
INTERP(xform[i].super_shape_n3);
INTERP(xform[i].super_shape_holes);
INTERP(xform[i].flower_petals);
INTERP(xform[i].flower_holes);
INTERP(xform[i].conic_eccentricity);
INTERP(xform[i].conic_holes);
INTERP(xform[i].parabola_height);
INTERP(xform[i].parabola_width);
INTERP(xform[i].bent2_x);
INTERP(xform[i].bent2_y);
INTERP(xform[i].bipolar_shift);
INTERP(xform[i].cell_size);
INTERP(xform[i].cpow_r);
INTERP(xform[i].cpow_i);
INTERP(xform[i].cpow_power);
INTERP(xform[i].curve_xamp);
INTERP(xform[i].curve_yamp);
INTERP(xform[i].curve_xlength);
INTERP(xform[i].curve_ylength);
INTERP(xform[i].escher_beta);
INTERP(xform[i].lazysusan_x);
INTERP(xform[i].lazysusan_y);
INTERP(xform[i].lazysusan_twist);
INTERP(xform[i].lazysusan_space);
INTERP(xform[i].lazysusan_spin);
INTERP(xform[i].modulus_x);
INTERP(xform[i].modulus_y);
INTERP(xform[i].oscope_separation);
INTERP(xform[i].oscope_frequency);
INTERP(xform[i].oscope_amplitude);
INTERP(xform[i].oscope_damping);
INTERP(xform[i].popcorn2_x);
INTERP(xform[i].popcorn2_y);
INTERP(xform[i].popcorn2_c);
INTERP(xform[i].separation_x);
INTERP(xform[i].separation_xinside);
INTERP(xform[i].separation_y);
INTERP(xform[i].separation_yinside);
INTERP(xform[i].split_xsize);
INTERP(xform[i].split_ysize);
INTERP(xform[i].splits_x);
INTERP(xform[i].splits_y);
INTERP(xform[i].stripes_space);
INTERP(xform[i].stripes_warp);
INTERP(xform[i].wedge_angle);
INTERP(xform[i].wedge_hole);
INTERP(xform[i].wedge_count);
INTERP(xform[i].wedge_swirl);
INTERP(xform[i].wedge_julia_angle);
INTERP(xform[i].wedge_julia_count);
INTERP(xform[i].wedge_julia_power);
INTERP(xform[i].wedge_julia_dist);
INTERP(xform[i].wedge_sph_angle);
INTERP(xform[i].wedge_sph_hole);
INTERP(xform[i].wedge_sph_count);
INTERP(xform[i].wedge_sph_swirl);
INTERP(xform[i].whorl_inside);
INTERP(xform[i].whorl_outside);
INTERP(xform[i].waves2_scalex);
INTERP(xform[i].waves2_scaley);
INTERP(xform[i].waves2_freqx);
INTERP(xform[i].waves2_freqy);
for (j = 0; j < flam3_nvariations; j++)
INTERP(xform[i].var[j]);
if (flam3_inttype_log == cpi[0].interpolation_type) {
double cxmag[4][2]; // XXX why only 4? should be ncp
double cxang[4][2];
double cxtrn[4][2];
/* affine part */
clear_matrix(result->xform[i].c);
convert_linear_to_polar(cpi,ncp,i,0,cxang,cxmag,cxtrn);
interp_and_convert_back(c, ncp, i, cxang, cxmag, cxtrn,result->xform[i].c);
/* post part */
all_id = 1;
for (k=0; k<ncp; k++)
all_id &= id_matrix(cpi[k].xform[i].post);
clear_matrix(result->xform[i].post);
if (all_id) {
result->xform[i].post[0][0] = 1.0;
result->xform[i].post[1][1] = 1.0;
} else {
convert_linear_to_polar(cpi,ncp,i,1,cxang,cxmag,cxtrn);
interp_and_convert_back(c, ncp, i, cxang, cxmag, cxtrn,result->xform[i].post);
}
} else {
/* Interpolate c matrix & post */
clear_matrix(result->xform[i].c);
clear_matrix(result->xform[i].post);
all_id = 1;
for (k = 0; k < ncp; k++) {
sum_matrix(c[k], cpi[k].xform[i].c, result->xform[i].c);
sum_matrix(c[k], cpi[k].xform[i].post, result->xform[i].post);
all_id &= id_matrix(cpi[k].xform[i].post);
}
if (all_id) {
clear_matrix(result->xform[i].post);
result->xform[i].post[0][0] = 1.0;
result->xform[i].post[1][1] = 1.0;
}
}
if (ncp==2 && stagger>0 && i!=cpi[0].final_xform_index) {
c[0] = csave[0];
c[1] = csave[1];
}
}
}
/* use catmullrom interpolation rather than linear */
void BKE_ocean_eval_uv_catrom(struct Ocean *oc, struct OceanResult *ocr, float u, float v)
{
int i0, i1, i2, i3, j0, j1, j2, j3;
float frac_x, frac_z;
float uu, vv;
/* first wrap the texture so 0 <= (u, v) < 1 */
u = fmod(u, 1.0f);
v = fmod(v, 1.0f);
if (u < 0) u += 1.0f;
if (v < 0) v += 1.0f;
BLI_rw_mutex_lock(&oc->oceanmutex, THREAD_LOCK_READ);
uu = u * oc->_M;
vv = v * oc->_N;
i1 = (int)floor(uu);
j1 = (int)floor(vv);
i2 = (i1 + 1);
j2 = (j1 + 1);
frac_x = uu - i1;
frac_z = vv - j1;
i1 = i1 % oc->_M;
j1 = j1 % oc->_N;
i2 = i2 % oc->_M;
j2 = j2 % oc->_N;
i0 = (i1 - 1);
i3 = (i2 + 1);
i0 = i0 < 0 ? i0 + oc->_M : i0;
i3 = i3 >= oc->_M ? i3 - oc->_M : i3;
j0 = (j1 - 1);
j3 = (j2 + 1);
j0 = j0 < 0 ? j0 + oc->_N : j0;
j3 = j3 >= oc->_N ? j3 - oc->_N : j3;
#define INTERP(m) catrom(catrom(m[i0 * oc->_N + j0], m[i1 * oc->_N + j0], \
m[i2 * oc->_N + j0], m[i3 * oc->_N + j0], frac_x), \
catrom(m[i0 * oc->_N + j1], m[i1 * oc->_N + j1], \
m[i2 * oc->_N + j1], m[i3 * oc->_N + j1], frac_x), \
catrom(m[i0 * oc->_N + j2], m[i1 * oc->_N + j2], \
m[i2 * oc->_N + j2], m[i3 * oc->_N + j2], frac_x), \
catrom(m[i0 * oc->_N + j3], m[i1 * oc->_N + j3], \
m[i2 * oc->_N + j3], m[i3 * oc->_N + j3], frac_x), \
frac_z)
{
if (oc->_do_disp_y) {
ocr->disp[1] = INTERP(oc->_disp_y);
}
if (oc->_do_normals) {
ocr->normal[0] = INTERP(oc->_N_x);
ocr->normal[1] = oc->_N_y /*INTERP(oc->_N_y) (MEM01)*/;
ocr->normal[2] = INTERP(oc->_N_z);
}
if (oc->_do_chop) {
ocr->disp[0] = INTERP(oc->_disp_x);
ocr->disp[2] = INTERP(oc->_disp_z);
}
else {
ocr->disp[0] = 0.0;
ocr->disp[2] = 0.0;
}
if (oc->_do_jacobian) {
compute_eigenstuff(ocr, INTERP(oc->_Jxx), INTERP(oc->_Jzz), INTERP(oc->_Jxz));
}
}
#undef INTERP
BLI_rw_mutex_unlock(&oc->oceanmutex);
}
/*
* create a control point that interpolates between the control points
* passed in CPS. for now just do linear. in the future, add control
* point types and other things to the cps. CPS must be sorted by time.
*/
void
interpolate (control_point cps[],
int ncps,
double time,
control_point *result)
{
int i, j, i1, i2;
double c0, c1, t;
if (ncps == 1)
{
*result = cps[0];
return;
}
if (cps[0].time >= time)
{
i1 = 0;
i2 = 1;
}
else if (cps[ncps - 1].time <= time)
{
i1 = ncps - 2;
i2 = ncps - 1;
}
else
{
i1 = 0;
while (cps[i1].time < time)
i1++;
i1--;
i2 = i1 + 1;
if (time - cps[i1].time > -1e-7 &&
time - cps[i1].time < 1e-7)
{
*result = cps[i1];
return;
}
}
c0 = (cps[i2].time - time) / (cps[i2].time - cps[i1].time);
c1 = 1.0 - c0;
result->time = time;
if (cps[i1].cmap_inter)
{
for (i = 0; i < 256; i++)
{
double spread = 0.15;
double d0, d1, e0, e1, c = 2 * G_PI * i / 256.0;
c = cos(c * cps[i1].cmap_inter) + 4.0 * c1 - 2.0;
if (c > spread) c = spread;
if (c < -spread) c = -spread;
d1 = (c + spread) * 0.5 / spread;
d0 = 1.0 - d1;
e0 = (d0 < 0.5) ? (d0 * 2) : (d1 * 2);
e1 = 1.0 - e0;
for (j = 0; j < 3; j++)
{
result->cmap[i][j] = (d0 * cps[i1].cmap[i][j] +
d1 * cps[i2].cmap[i][j]);
#define bright_peak 2.0
result->cmap[i][j] = (e1 * result->cmap[i][j] +
e0 * 1.0);
}
}
}
else
{
for (i = 0; i < 256; i++)
{
double t[3], s[3];
rgb2hsv (cps[i1].cmap[i], s);
rgb2hsv (cps[i2].cmap[i], t);
for (j = 0; j < 3; j++)
t[j] = c0 * s[j] + c1 * t[j];
hsv2rgb (t, result->cmap[i]);
}
}
result->cmap_index = -1;
INTERP(brightness);
INTERP(contrast);
INTERP(gamma);
INTERP(width);
INTERP(height);
INTERP(spatial_oversample);
INTERP(center[0]);
INTERP(center[1]);
INTERP(pixels_per_unit);
INTERP(spatial_filter_radius);
INTERP(sample_density);
INTERP(zoom);
INTERP(nbatches);
INTERP(white_level);
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
{
INTERP(pulse[i][j]);
INTERP(wiggle[i][j]);
}
for (i = 0; i < NXFORMS; i++)
{
double r;
INTERP(xform[i].density);
if (result->xform[i].density > 0)
result->xform[i].density = 1.0;
INTERP(xform[i].color);
for (j = 0; j < NVARS; j++)
INTERP(xform[i].var[j]);
t = 0.0;
for (j = 0; j < NVARS; j++)
t += result->xform[i].var[j];
t = 1.0 / t;
for (j = 0; j < NVARS; j++)
result->xform[i].var[j] *= t;
interpolate_matrix(c1, cps[i1].xform[i].c, cps[i2].xform[i].c,
result->xform[i].c);
if (1)
{
double rh_time = time * 2 * G_PI / (60.0 * 30.0);
/* apply pulse factor. */
r = 1.0;
for (j = 0; j < 2; j++)
r += result->pulse[j][0] * sin(result->pulse[j][1] * rh_time);
for (j = 0; j < 3; j++)
{
result->xform[i].c[j][0] *= r;
result->xform[i].c[j][1] *= r;
}
/* apply wiggle factor */
r = 0.0;
for (j = 0; j < 2; j++)
{
double tt = result->wiggle[j][1] * rh_time;
double m = result->wiggle[j][0];
result->xform[i].c[0][0] += m * cos(tt);
result->xform[i].c[1][0] += m * -sin(tt);
result->xform[i].c[0][1] += m * sin(tt);
result->xform[i].c[1][1] += m * cos(tt);
}
}
} /* for i */
}
OP_ERROR
SOP_Ocean::cookMySop(OP_Context &context)
{
float now = context.getTime();
//std::cout << "cook ocean, t = " << now << std::endl;
// lock inputs
if (lockInputs(context) >= UT_ERROR_ABORT )
{
return error();
}
GEO_Point *ppt;
UT_Interrupt *boss;
// Check to see that there hasn't been a critical error in cooking the SOP.
if (error() < UT_ERROR_ABORT)
{
boss = UTgetInterrupt();
// Start the interrupt server
boss->opStart("Updating Ocean");
duplicatePointSource(0,context);
int gridres = 1 << int(GRID_RES(now));
float stepsize = GRID_SIZE(now) / (float)gridres;
bool do_chop = CHOP(now);
bool do_jacobian = JACOBIAN(now);
bool do_normals = NORMALS(now) && !do_chop;
if (!_ocean || _ocean_needs_rebuild)
{
if (_ocean)
{
delete _ocean;
}
if (_ocean_context)
{
delete _ocean_context;
}
_ocean = new drw::Ocean(gridres,gridres,stepsize,stepsize,
V(0),L(0),1.0,W(0),1-DAMP(0),ALIGN(0),
DEPTH(0),SEED(0));
_ocean_scale = _ocean->get_height_normalize_factor();
_ocean_context = _ocean->new_context(true,do_chop,do_normals,do_jacobian);
_ocean_needs_rebuild = false;
// std::cout << "######### SOP, rebuilt ocean, norm_factor = " << _ocean_scale
// << " chop = " << do_chop
// << " norm = " << do_normals
// << " jacobian = " << do_jacobian
// << std::endl;
}
float chop_amount = CHOPAMOUNT(now);
// sum up the waves at this timestep
_ocean->update(TIME(now),*_ocean_context,true,do_chop,do_normals,do_jacobian,
_ocean_scale * SCALE(now),chop_amount);
bool linterp = ! INTERP(now);
// get our attribute indices
GA_RWAttributeRef normal_index;
GA_RWAttributeRef jminus_index;
GA_RWAttributeRef eminus_index;
if (do_normals)
{
normal_index = gdp->addNormalAttribute(GEO_POINT_DICT);
}
if (do_jacobian)
{
// jminus_index = gdp->addPointAttrib("mineigval",sizeof(float),GB_ATTRIB_FLOAT,0);
// eminus_index = gdp->addPointAttrib("mineigvec",sizeof(UT_Vector3),GB_ATTRIB_VECTOR,0);
jminus_index = gdp->addTuple(GA_STORE_REAL32,GA_ATTRIB_POINT,"mineigval",1,GA_Defaults(0));
eminus_index = gdp->addFloatTuple(GA_ATTRIB_POINT,"mineigvec",1,GA_Defaults(0));
}
// this is not that fast, can it be done quicker ???
GA_FOR_ALL_GPOINTS(gdp, ppt)
{
UT_Vector4 p = ppt->getPos();
if (linterp)
{
_ocean_context->eval_xz(p(0),p(2));
}
else
{
_ocean_context->eval2_xz(p(0),p(2));
}
if (do_chop)
{
p.assign( p(0) + _ocean_context->disp[0],
p(1) + _ocean_context->disp[1],
p(2) + _ocean_context->disp[2] );
}
else
{
// ppt->getPos()(1) += _ocean_context->disp[1];
UT_Vector4 tmp_p = ppt->getPos();
tmp_p(1) += _ocean_context->disp[1];
ppt->setPos(tmp_p);
}
if (do_normals)
{
/*
UT_Vector3* normal = (UT_Vector3*) ppt->castAttribData<UT_Vector3>(normal_index);
normal->assign(_ocean_context->normal[0],
_ocean_context->normal[1],
_ocean_context->normal[2]);
normal->normalize();
*/
ppt->getValue<UT_Vector3>(normal_index).assign(_ocean_context->normal[0],
_ocean_context->normal[1],
_ocean_context->normal[2]);
ppt->getValue<UT_Vector3>(normal_index).normalize();
}
if (do_jacobian)
{/*
float *js = (float*)ppt->castAttribData<float>(jminus_index);
*js = _ocean_context->Jminus;
UT_Vector3* eminus = (UT_Vector3*)ppt->castAttribData<UT_Vector3>(eminus_index);
eminus->assign(_ocean_context->Eminus[0],0,_ocean_context->Eminus[1]);
*/
ppt->setValue<float>(jminus_index,_ocean_context->Jminus);
ppt->getValue<UT_Vector3>(eminus_index).assign(_ocean_context->Eminus[0],0,_ocean_context->Eminus[1]);
}
ppt->setPos(p);
}
