void CMouthComponent::renderComponentInColor( std::vector<cv::Point> templatePoints, cv::Mat templateMat, int width, int height )
{
warpedTemplate = cvCreateMat(height, width, CV_8UC3);
warpedTemplate.setTo(255);
std::vector<cv::Point> mouthPoints = getLocatedPoints();
for (int i = 0; i< mouthPoints.size(); i++)
{
int j;
if ( i == 11 || i == 19)
{
j = 0;
}
else
{
j = i + 1;
}
cv::Point kp1 = mouthPoints[i];
cv::Point kp2 = mouthPoints[j];
cv::line(warpedTemplate, kp1, kp2,cv::Scalar(70, 75, 170), 1);
}
cv::Mat_<cv::Vec3b> _I = warpedTemplate;
#pragma omp parallel for
for( int row = 0; row < warpedTemplate.rows; ++row){
for( int col = 0; col < warpedTemplate.cols; ++col )
{
double isMouthPoint = pointPolygonTest( mouthPoints, cv::Point2f(col,row), false );
if(isMouthPoint > 0){
_I(row,col)[0] = 100;
_I(row,col)[1] = 100;
_I(row,col)[2] = 200;
}
}
}
warpedTemplate = _I;
}
static void p2_test_onelarger2(void)
{
// Square centered on 2,2
struct PC_vertex_ll * r1 = createRect(2,2,4,4);
// Square centered on 3,4
struct PC_vertex_ll * r2 = createRect(3,3,6,6);
enum PC_op_t op = PC_op_union;
bool result = PC_phase_one(r1, r2);
LT_REQUIRE(polySize(r1) == 4);
LT_REQUIRE(polySize(r2) == 6);
PC_phase_two(r1, r2, op);
LT_ASSERT(_I(r1, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 1)->flag == FLG_EN);
LT_ASSERT(_I(r1, 2)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 3)->flag == FLG_EX);
LT_ASSERT(_I(r2, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 1)->flag == FLG_EX);
LT_ASSERT(_I(r2, 2)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 3)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 4)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 5)->flag == FLG_EN);
LT_ASSERT(no_couples(r1));
LT_ASSERT(no_couples(r2));
PC_free_verticies(r1);
PC_free_verticies(r2);
}
std::list<cv::Mat> partition(cv::Mat &I)
{
cv::Mat mat = I.clone();
cv::Mat_<cv::Vec3b> _I = mat;
std::list< cv::Mat > list;
for( int i = 0; i < mat.rows; ++i){
for( int j = 0; j < mat.cols; ++j ){
if(_I(i, j)[0] == 0){
list.push_back(floodCutting(mat, i, j));
}
}
}
return list;
}
void erose(cv::Mat &I) {
Matrix _I = I;
cv::Mat R = I.clone();
Matrix _R = R;
for_pixel(I,
[&_I, &I, &_R] (int row, int col) {
for_neighbour(row, col,
[&_R, &_I, &I, row, col] (int x, int y) {
Point point = normalize(I, x ,y);
if (gray(_R(point.x, point.y)) == 255) {
_I(row, col) = {255, 255, 255};
return false;
}
return true;
}
);
return true;
}
);
}
inline void Fluid::diffuse(int b, float* x0, float* x, float diff, float dt)
{
int i, j, k, l;
float a=dt*diff*N*N*N;
for (l=0; l<20; l++)
{
for (k=1; k<=N; k++)
{
for (j=1; j<=N; j++)
{
for (i=1; i<=N; i++)
{
x[_I(i,j,k)] = (x0[_I(i,j,k)] + a*(
x[_I(i-1,j,k)]+x[_I(i+1,j,k)]+
x[_I(i,j-1,k)]+x[_I(i,j+1,k)]+
x[_I(i,j,k-1)]+x[_I(i,j,k+1)]))/(1+6*a);
}
}
}
set_bnd(b,x);
}
}
const ExprApply& Function::operator()(const IntervalVector& arg0, const ExprNode& arg1, const Interval& arg2) { return (*this)(_V(1,0), arg1, _I(1,2)); }
const ExprApply& Function::operator()(const ExprNode& arg0, const IntervalMatrix& arg1, const Interval& arg2) { return (*this)(arg0, _M(0,1), _I(0,2)); }
const ExprApply& Function::operator()(const Interval& arg0, const ExprNode& arg1) { return (*this)(_I(1,0),arg1); }
const ExprApply& Function::operator()(const ExprNode& arg0, const Interval& arg1) { return (*this)(arg0,_I(0,1)); }
int
nsc_cache_sizes(int *asize, int *wsize)
{
return (_nsc_call_io(_I(sizes), (blind_t)asize, (blind_t)wsize, 0));
}
int
nsc_node_hints_set(uint_t hints)
{
return (_nsc_call_io(_I(nodehints), (blind_t)(unsigned long)hints,
(blind_t)NSC_SET_NODE_HINT, 0));
}
static void p2_test_overlapping_rects_2(void)
{
// Square centered on 2,2
struct PC_vertex_ll * r1 = createRect(2,2,4,4);
// Square centered on 4,4
struct PC_vertex_ll * r2 = createRectCW(4,4,4,4);
enum PC_op_t op = PC_op_union;
bool result = PC_phase_one(r1, r2);
PC_phase_two(r1, r2, op);
// Should be:
/*
*
*
* R2_2-------------------R2_3
* | |
* | |
* R1_5--R1_4/R2_1--R1_3 |
* | | | |
* | | | |
* | R2_0------R1_2/R2_5----R2_4
* | |
* | |
* R1_0-------------R1_1
*
*/
LT_ASSERT(_I(r1, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 1)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 2)->flag == FLG_EN);
LT_ASSERT(_I(r1, 3)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 4)->flag == FLG_EX);
LT_ASSERT(_I(r1, 5)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 1)->flag == FLG_EX);
LT_ASSERT(_I(r2, 2)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 3)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 4)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 5)->flag == FLG_EN);
LT_ASSERT(no_couples(r1));
LT_ASSERT(no_couples(r2));
PC_free_verticies(r1);
PC_free_verticies(r2);
}
int icmp(const void *a, const void *b)
{
#define _I(x) *(int*)x
return _I(a) < _I(b) ? -1 : _I(a) > _I(b);
#undef _I
}
inline void DIV(int &a, int b){MUL(a, _I(b));}
void Fluid::vorticity_confinement(float dt)
{
int i,j,k,ijk;
float *curlx = u0, *curly = v0, *curlz=w0, *curl=T0; // temp buffers
float dt0 = dt * vc_eps;
float x,y,z;
for (k=1; k<N; k++) {
for (j=1; j<N; j++) {
for (i=1; i<N; i++) {
ijk = _I(i,j,k);
// curlx = dw/dy - dv/dz
x = curlx[ijk] = (w[_I(i,j+1,k)] - w[_I(i,j-1,k)]) * 0.5f -
(v[_I(i,j,k+1)] - v[_I(i,j,k-1)]) * 0.5f;
// curly = du/dz - dw/dx
y = curly[ijk] = (u[_I(i,j,k+1)] - u[_I(i,j,k-1)]) * 0.5f -
(w[_I(i+1,j,k)] - w[_I(i-1,j,k)]) * 0.5f;
// curlz = dv/dx - du/dy
z = curlz[ijk] = (v[_I(i+1,j,k)] - v[_I(i-1,j,k)]) * 0.5f -
(u[_I(i,j+1,k)] - u[_I(i,j-1,k)]) * 0.5f;
// curl = |curl|
curl[ijk] = sqrtf(x*x+y*y+z*z);
}
}
}
for (k=1; k<N; k++) {
for (j=1; j<N; j++) {
for (i=1; i<N; i++) {
ijk = _I(i,j,k);
float Nx = (curl[_I(i+1,j,k)] - curl[_I(i-1,j,k)]) * 0.5f;
float Ny = (curl[_I(i,j+1,k)] - curl[_I(i,j-1,k)]) * 0.5f;
float Nz = (curl[_I(i,j,k+1)] - curl[_I(i,j,k-1)]) * 0.5f;
float len1 = 1.0f/(sqrtf(Nx*Nx+Ny*Ny+Nz*Nz)+0.0000001f);
Nx *= len1;
Ny *= len1;
Nz *= len1;
u[ijk] += (Ny*curlz[ijk] - Nz*curly[ijk]) * dt0;
v[ijk] += (Nz*curlx[ijk] - Nx*curlz[ijk]) * dt0;
w[ijk] += (Nx*curly[ijk] - Ny*curlx[ijk]) * dt0;
}
}
}
}
void Fluid::project(void)
{
float* p = u0; float* div = v0; // temporary buffers, use old velocity buffers
int i, j, k, l;
float h;
h = 1.0f/N;
for (k=1; k<=N; k++) {
for (j=1; j<=N; j++) {
for (i=1; i<=N; i++) {
div[_I(i,j,k)] = -h*(
u[_I(i+1,j,k)]-u[_I(i-1,j,k)]+
v[_I(i,j+1,k)]-v[_I(i,j-1,k)]+
w[_I(i,j,k+1)]-w[_I(i,j,k-1)])/3;
p[_I(i,j,k)] = 0;
}
}
}
set_bnd(0,div); set_bnd(0,p);
for (l=0; l<20; l++)
{
for (k=1; k<=N; k++) {
for (j=1; j<=N; j++) {
for (i=1; i<=N; i++) {
p[_I(i,j,k)] = (div[_I(i,j,k)]+
p[_I(i-1,j,k)]+p[_I(i+1,j,k)]+
p[_I(i,j-1,k)]+p[_I(i,j+1,k)]+
p[_I(i,j,k-1)]+p[_I(i,j,k+1)])/6;
}
}
}
set_bnd(0,p);
}
for (k=1; k<=N; k++) {
for (j=1; j<=N; j++) {
for (i=1; i<=N; i++) {
u[_I(i,j,k)] -= (p[_I(i+1,j,k)]-p[_I(i-1,j,k)])/3/h;
v[_I(i,j,k)] -= (p[_I(i,j+1,k)]-p[_I(i,j-1,k)])/3/h;
w[_I(i,j,k)] -= (p[_I(i,j,k+1)]-p[_I(i,j,k-1)])/3/h;
}
}
}
set_bnd(1,u); set_bnd(2,v);
}
inline void Fluid::advect_cool(int b, float* x0, float* x, float* y0, float* y, float* uu, float* vv, float* ww, float dt)
{
int i, j, k, i0, j0, k0, i1, j1, k1;
float sx0, sx1, sy0, sy1, sz0, sz1, v0, v1;
float xx, yy, zz, dt0, c0;
dt0 = dt*N;
c0 = 1.0f - cooling*dt;
for (k=1; k<=N; k++)
{
for (j=1; j<=N; j++)
{
for (i=1; i<=N; i++)
{
xx = i-dt0*uu[_I(i,j,k)];
yy = j-dt0*vv[_I(i,j,k)];
zz = k-dt0*ww[_I(i,j,k)];
if (xx<0.5) xx=0.5f; if (xx>N+0.5) xx=N+0.5f; i0=(int)xx; i1=i0+1;
if (yy<0.5) yy=0.5f; if (yy>N+0.5) yy=N+0.5f; j0=(int)yy; j1=j0+1;
if (zz<0.5) zz=0.5f; if (zz>N+0.5) zz=N+0.5f; k0=(int)zz; k1=k0+1;
sx1 = xx-i0; sx0 = 1-sx1;
sy1 = yy-j0; sy0 = 1-sy1;
sz1 = zz-k0; sz0 = 1-sz1;
v0 = sx0*(sy0*x0[_I(i0,j0,k0)]+sy1*x0[_I(i0,j1,k0)])+sx1*(sy0*x0[_I(i1,j0,k0)]+sy1*x0[_I(i1,j1,k0)]);
v1 = sx0*(sy0*x0[_I(i0,j0,k1)]+sy1*x0[_I(i0,j1,k1)])+sx1*(sy0*x0[_I(i1,j0,k1)]+sy1*x0[_I(i1,j1,k1)]);
x[_I(i,j,k)] = sz0*v0 + sz1*v1;
v0 = sx0*(sy0*y0[_I(i0,j0,k0)]+sy1*y0[_I(i0,j1,k0)])+sx1*(sy0*y0[_I(i1,j0,k0)]+sy1*y0[_I(i1,j1,k0)]);
v1 = sx0*(sy0*y0[_I(i0,j0,k1)]+sy1*y0[_I(i0,j1,k1)])+sx1*(sy0*y0[_I(i1,j0,k1)]+sy1*y0[_I(i1,j1,k1)]);
y[_I(i,j,k)] = (sz0*v0 + sz1*v1)*c0;
}
}
}
set_bnd(b,d);
}
IplImage* callback(IplImage* image)
{
IplImage* Show1 = cvCreateImage( cvSize(640,480), IPL_DEPTH_8U, 1);
IplImage* Show2 = cvCreateImage( cvSize(640,480), IPL_DEPTH_8U, 1);
IplImage* ImageC1 = cvCreateImage( cvSize(640,480), IPL_DEPTH_8U, 1);
//转换为灰度图
cvCvtColor( image, ImageC1, CV_RGB2GRAY);
// cvFlip( ImageC1, NULL, 0);
double *mi;
double *md;
mi = new double[3*3];
md = new double[4];
CvMat intrinsic_matrix,distortion_coeffs;
//摄像机内参数
cvInitMatHeader(&intrinsic_matrix,3,3,CV_64FC1,mi);
//镜头畸变参数
cvInitMatHeader(&distortion_coeffs,1,4,CV_64FC1,md);
/////////////////////////////////////////////////
double fc1,fc2,cc1,cc2,kc1,kc2,kc3,kc4;
/*fc1 = 636.796592;
fc2 = 639.002846;
cc1 = 320.575856;
cc2 = 238.909624;
kc1 = 0.008447;
kc2 = -0.072905;
kc3 = -0.001818;
kc4 = -0.000562; */
fc1 = 426.331624;
fc2 = 426.556478;
cc1 = 365.956413;
cc2 = 202.451300;
kc1 = -0.422263;
kc2 = 0.182853;
kc3 = -0.007801;
kc4 = 0.002509;
cvmSet(&intrinsic_matrix, 0, 0, fc1);
cvmSet(&intrinsic_matrix, 0, 1, 0);
cvmSet(&intrinsic_matrix, 0, 2, cc1);
cvmSet(&intrinsic_matrix, 1, 0, 0);
cvmSet(&intrinsic_matrix, 1, 1, fc2);
cvmSet(&intrinsic_matrix, 1, 2, cc2);
cvmSet(&intrinsic_matrix, 2, 0, 0);
cvmSet(&intrinsic_matrix, 2, 1, 0);
cvmSet(&intrinsic_matrix, 2, 2, 1);
cvmSet(&distortion_coeffs, 0, 0, kc1);
cvmSet(&distortion_coeffs, 0, 1, kc2);
cvmSet(&distortion_coeffs, 0, 2, kc3);
cvmSet(&distortion_coeffs, 0, 3, kc4);
/////////////////////////////////////////////////
//下面有两种矫正方法，第一种用opencv库，第二种自定义方法
//矫正畸变(opencv)
cvUndistort2( ImageC1, Show1, &intrinsic_matrix, &distortion_coeffs);
//矫正畸变
for (int nx=0; nx<640; nx++)
{
for (int ny=0; ny<480; ny++)
{
// double x=nx-50;
// double y=ny-50;
double x=nx;
double y=ny;
double xx=(x-cc1)/fc1;
double yy=(y-cc2)/fc2;
double r2=pow(xx,2)+pow(yy,2);
double r4=pow(r2,2);
double xxx=xx*(1+kc1*r2+kc2*r4)+2*kc3*xx*yy+kc4*(r2+2*xx*xx);
double yyy=yy*(1+kc1*r2+kc2*r4)+2*kc4*xx*yy+kc3*(r2+2*yy*yy);
double xxxx = xxx*fc1+cc1;
double yyyy = yyy*fc2+cc2;
if (xxxx>0 && xxxx<640 && yyyy>0 && yyyy<480)
{
_I(Show2,nx,ny) = (int)_IF(ImageC1,xxxx,yyyy);
}
else
{
_I(Show2,nx,ny) = 0;
}
}
}
//显示
// cvShowImage("径向矫正1", Show1);
// cvShowImage("径向矫正2", Show2);
// cvWaitKey(1);
cvReleaseImage( &Show1 );
// cvReleaseImage( &Show2 );
cvReleaseImage( &ImageC1 );
return Show2; //选了第二种方法
}
const ExprApply& Function::operator()(const IntervalMatrix& arg0, const Interval& arg1, const ExprNode& arg2) { return (*this)(_M(2,0), _I(2,1), arg2); }
bool CleanTask::performTask()
{
Logger l( className(), "performTask" );
DataSet to_delete;
int index = 0;
try{
//marking to remove outliers
Logger::log_info( "searching for outliers..." );
Logger::log_info_end();
while( valid_for_cleaning_column[index] != _IND(DatabaseColumnFinal) )
{
DataSet ad;
ad = PreProcessingTask::standartDeviation( _data_set, valid_for_cleaning_column[index] );
for( int i = 1; i < _data_set.size(); i++ ){
to_delete[i] = 0;
}
for( int i = 1; i < _data_set.size(); i++ ){
double value = _data_set[i][valid_for_cleaning_column[index]].getType() == DataSet::TypeInt ?
_D(_I(_data_set[i][valid_for_cleaning_column[index]])) :
_D(_data_set[i][valid_for_cleaning_column[index]]);
double avg = _D(ad["avg"]);
double dev = _outlierDeviation*_D(ad["dev"]);
if( (value < 0) || (absf( value - _D(ad["avg"])) > (_outlierDeviation*_D(ad["dev"])))){
to_delete[i] = 1;
}
}
index++;
}
//marking to remove invalid values
index = 0;
while( valid_for_normalizing_column[index] != _IND(DatabaseColumnFinal) )
{
DataSet ad;
for( int i = 1; i < _data_set.size(); i++ ){
double value = _data_set[i][valid_for_normalizing_column[index]].getType() == DataSet::TypeInt ?
_D(_I(_data_set[i][valid_for_normalizing_column[index]])) :
_D(_data_set[i][valid_for_normalizing_column[index]]);
if( value < 0 ){
to_delete[i] = 1;
}
}
index++;
}
//removing items
Logger::log_info( "cleaning data..." );
Logger::log_info_end();
DataSet ds;
index = 1;
ds[0] = _data_set[0];
for( int i = 1; i < _data_set.size(); i++ ){
if( !_I(to_delete[i]) )
ds[index++] = _data_set[i];
}
_data_set.clear();
_data_set = ds;
ds.clear();
} catch( Exception &e ){
Logger::log_except( "Problem performing CleanTask", e.what() );
return false;
} catch( ... ){
Logger::log_except( "Problem performing CleanTask" );
return false;
}
return true;
}
int icmp(const void *a, const void *b)
{
#define _I(x) *(const int*)x
return _I(a) < _I(b) ? -1 : _I(a) > _I(b);
#undef _I
}
static void p2_test_semi2(void)
{
struct PC_vertex_ll * r1 = createRect(2,2,4,4);
struct PC_vertex_ll * r2 = createRectCW(4,3,2,2);
enum PC_op_t op = PC_op_union;
bool result = PC_phase_one(r1, r2);
LT_REQUIRE(polySize(r1) == 6);
LT_REQUIRE(polySize(r2) == 6);
PC_phase_two(r1, r2, op);
LT_ASSERT(_I(r1, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 1)->flag == FLG_NONE);
LT_ASSERT(_I(r1, 2)->flag == FLG_EN);
LT_ASSERT(_I(r1, 3)->flag == FLG_EX);
LT_ASSERT(_I(r1, 4)->flag == FLG_EX);
LT_ASSERT(_I(r1, 5)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 0)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 1)->flag == FLG_EX);
LT_ASSERT(_I(r2, 2)->flag == FLG_EX);
LT_ASSERT(_I(r2, 3)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 4)->flag == FLG_NONE);
LT_ASSERT(_I(r2, 5)->flag == FLG_EN);
// Test couple creation
LT_ASSERT(_I(r1, 0)->couple == NULL);
LT_ASSERT(_I(r1, 1)->couple == NULL);
LT_ASSERT(_I(r1, 2)->couple == NULL);
LT_ASSERT(_I(r1, 3)->couple == _I(r1, 4));
LT_ASSERT(_I(r1, 4)->couple == _I(r1, 3));
LT_ASSERT(_I(r1, 5)->couple == NULL);
LT_ASSERT(_I(r2, 0)->couple == NULL);
LT_ASSERT(_I(r2, 1)->couple == _I(r2, 2));
LT_ASSERT(_I(r2, 2)->couple == _I(r2, 1));
LT_ASSERT(_I(r2, 3)->couple == NULL);
LT_ASSERT(_I(r2, 4)->couple == NULL);
LT_ASSERT(_I(r2, 5)->couple == NULL);
PC_free_verticies(r1);
PC_free_verticies(r2);
}
inline int qtt(int a, int b){return pdt(a, _I(b));}
#define __NSC_GEN__
#include "nsc_dev.h"
#ifdef DS_DDICT
#include "../contract.h"
#endif
#include "../nsctl.h"
#define _I(x) (((long)(&((nsc_io_t *)0)->x))/sizeof (long))
nsc_def_t _nsc_cache_def[] = {
"AllocBuf", (uintptr_t)nsc_ioerr, _I(alloc_buf),
"FreeBuf", (uintptr_t)nsc_fatal, _I(free_buf),
"Read", (uintptr_t)nsc_fatal, _I(read),
"Write", (uintptr_t)nsc_fatal, _I(write),
"Zero", (uintptr_t)nsc_fatal, _I(zero),
"Copy", (uintptr_t)nsc_ioerr, _I(copy),
"CopyDirect", (uintptr_t)nsc_ioerr, _I(copy_direct),
"Uncommit", (uintptr_t)nsc_null, _I(uncommit),
"AllocHandle", (uintptr_t)nsc_null, _I(alloc_h),
"FreeHandle", (uintptr_t)nsc_fatal, _I(free_h),
"TrackSize", (uintptr_t)nsc_null, _I(trksize),
"Discard", (uintptr_t)nsc_null, _I(discard),
"Sizes", (uintptr_t)nsc_null, _I(sizes),
"GetPinned", (uintptr_t)nsc_null, _I(getpin),
"NodeHints", (uintptr_t)nsc_inval, _I(nodehints),
0, 0, 0
#endif
#define _FN0(rt, s, d, f) _FN(SEXP_OP_FCALL0, 0, 0, rt, SEXP_FALSE, SEXP_FALSE, SEXP_FALSE, s, d, f)
#define _FN1(rt, a1, s, d, f) _FN(SEXP_OP_FCALL1, 1, 0, rt, a1, SEXP_FALSE, SEXP_FALSE, s, d, f)
#define _FN1OPT(rt, a1, s, d, f) _FN(SEXP_OP_FCALL1, 0, 1, rt, a1, SEXP_FALSE, SEXP_FALSE, s, d, f)
#define _FN1OPTP(rt, a1, s, d, f) _FN(SEXP_OP_FCALL1, 0, 3, rt, a1, SEXP_FALSE, SEXP_FALSE, s, d, f)
#define _FN2(rt, a1, a2, s, d, f) _FN(SEXP_OP_FCALL2, 2, 0, rt, a1, a2, SEXP_FALSE, s, d, f)
#define _FN2OPT(rt, a1, a2, s, d, f) _FN(SEXP_OP_FCALL2, 1, 1, rt, a1, a2, SEXP_FALSE, s, d, f)
#define _FN2OPTP(rt, a1, a2, s, d, f) _FN(SEXP_OP_FCALL2, 1, 3, rt, a1, a2, SEXP_FALSE, s, d, f)
#define _FN3(rt, a1, a2, a3, s, d, f) _FN(SEXP_OP_FCALL3, 3, 0, rt, a1, a2, a3, s, d, f)
#define _FN3OPT(rt, a1, a2, a3, s, d, f) _FN(SEXP_OP_FCALL3, 2, 1, rt, a1, a2, a3, s, d, f)
#define _FN4(rt, a1, a2, a3, s, d, f) _FN(SEXP_OP_FCALL4, 4, 0, rt, a1, a2, a3, s, d, f)
#define _FN5(rt, a1, a2, a3, s, d, f) _FN(SEXP_OP_FCALLN, 5, 0, rt, a1, a2, a3, s, d, f)
static struct sexp_opcode_struct opcodes[] = {
_PARAM("current-input-port", _I(SEXP_IPORT)),
_PARAM("current-output-port", _I(SEXP_OPORT)),
_PARAM("current-error-port", _I(SEXP_OPORT)),
_PARAM("current-exception-handler", _I(SEXP_PROCEDURE)),
_PARAM("interaction-environment", _I(SEXP_ENV)),
_PARAM("current-usage-environment", _I(SEXP_ENV)),
_PARAM("current-transformer-environment", _I(SEXP_ENV)),
_PARAM("current-renamer", _I(SEXP_PROCEDURE)),
_PARAM("command-line", SEXP_NULL),
_OP(SEXP_OPC_GETTER, SEXP_OP_CAR, 1, 0, _I(SEXP_OBJECT), _I(SEXP_PAIR), SEXP_FALSE, SEXP_FALSE, 0, "car", 0, NULL),
_OP(SEXP_OPC_SETTER, SEXP_OP_SET_CAR, 2, 0, SEXP_VOID, _I(SEXP_PAIR), _I(SEXP_OBJECT), SEXP_FALSE, 0, "set-car!", 0, NULL),
_OP(SEXP_OPC_GETTER, SEXP_OP_CDR, 1, 0, _I(SEXP_OBJECT), _I(SEXP_PAIR), SEXP_FALSE, SEXP_FALSE, 0, "cdr", 0, NULL),
_OP(SEXP_OPC_SETTER, SEXP_OP_SET_CDR, 2, 0, SEXP_VOID, _I(SEXP_PAIR), _I(SEXP_OBJECT), SEXP_FALSE, 0, "set-cdr!", 0, NULL),
_GETTER("pair-source", SEXP_PAIR, 2),
_SETTER("pair-source-set!", SEXP_PAIR, 2),
_GETTER("syntactic-closure-rename", SEXP_SYNCLO, 3),
int
nsc_node_hints(uint_t *hints)
{
return (_nsc_call_io(_I(nodehints), (blind_t)hints,
(blind_t)NSC_GET_NODE_HINT, 0));
}
