Node* CylinderSurfaceModule::evaluate(Context* ctx)
{
NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
decimal h=1.0;
if(heightValue)
h=heightValue->getNumber();
NumberValue* rValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1));
decimal r=1.0;
if(rValue)
r=rValue->getNumber();
Value* centerValue=getParameterArgument(ctx,2);
bool center=false;
if(centerValue)
center=centerValue->isTrue();
decimal z1,z2;
z1 = 0.0;
z2 = h;
Fragment* fg = Fragment::createFragment(ctx);
int f = fg->getFragments(r);
delete fg;
QList<Point> c1=getCircle(r,f,z1);
QList<Point> c2=getCircle(r,f,z2);
PrimitiveNode* p=new PrimitiveNode(reporter);
p->setChildren(ctx->getInputNodes());
foreach(Point pt,c1) {
p->createVertex(pt);
}
Node* CylinderModule::evaluate(Context* ctx)
{
NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
decimal h=1.0;
if(heightValue)
h=heightValue->getNumber();
NumberValue* r1Value = dynamic_cast<NumberValue*>(ctx->getArgument(1,"radius1"));
NumberValue* r2Value = dynamic_cast<NumberValue*>(ctx->getArgument(2,"radius2"));
BooleanValue* centerValue;
decimal r1=1.0,r2=1.0;
if(!r1Value) {
NumberValue* rValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1));
centerValue = dynamic_cast<BooleanValue*>(getParameterArgument(ctx,2));
if(rValue) {
r1=r2=rValue->getNumber();
} else {
NumberValue* dValue = dynamic_cast<NumberValue*>(ctx->getArgument(1,"diameter"));
if(dValue)
r1=r2=(dValue->getNumber()/2.0);
}
} else {
if(r1Value)
r1=r1Value->getNumber();
if(r2Value)
r2=r2Value->getNumber();
else
r2=r1;
centerValue = dynamic_cast<BooleanValue*>(ctx->getArgument(3,"center"));
}
bool center = false;
if(centerValue)
center=centerValue->isTrue();
decimal z1,z2;
z1 = 0.0;
z2 = h;
decimal r=fmax(r1,r2);
Fragment fg=getSpecialVariables(ctx);
int f = fg.getFragments(r);
QList<Point> c1=getCircle(r1,f,z1);
QList<Point> c2=getCircle(r2,f,z2);
PrimitiveNode* p = new PrimitiveNode();
int n=0;
Polygon* pg;
if(r1>0) {
pg=p->createPolygon();
foreach(Point pt,c1) {
p->createVertex(pt);
pg->append(n++);
}
void fillEllipse(
const geom::Point2D& center,
const geom::Point2D& radius,
int sizeIdx)
{
glPushMatrix();
{
int size;
P2* a = getCircle(sizeIdx, size);
glTranslatef(center.x, center.y, 0.f);
glScalef(radius.x, radius.y, 1.f);
glBegin(GL_TRIANGLE_FAN);
{
glVertex2f(0.f, 0.f);
for (int i = 0; i != size - 1; ++i)
{
glVertex2f(a[i].x, a[i].y);
glVertex2f(a[i+1].x, a[i+1].y);
}
glVertex2f(a[size - 1].x, a[size - 1].y);
glVertex2f(a[0].x, a[0].y);
}
glEnd();
}
glPopMatrix();
}
Node* CylinderSurfaceModule::evaluate(Context* ctx)
{
NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
double h=1.0;
if(heightValue)
h=heightValue->getNumber();
NumberValue* rValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1));
double r=1.0;
if(rValue)
r=rValue->getNumber();
Value* centerValue=getParameterArgument(ctx,2);
bool center=false;
if(centerValue)
center=centerValue->isTrue();
double z1,z2;
if(center) {
z1 = -h/2;
z2 = +h/2;
} else {
z1 = 0.0;
z2 = h;
}
int f = getFragments(r,ctx);
Polygon c1 = getCircle(r,f,z1);
Polygon c2 = getCircle(r,f,z2);
PrimitiveNode* p = new PrimitiveNode();
for(int i=0; i<f; i++) {
int j=(i+1)%f;
p->createPolygon();
p->appendVertex(c1.at(i));
p->appendVertex(c2.at(i));
p->appendVertex(c2.at(j));
p->appendVertex(c1.at(j));
}
return p;
}
void MesherFixedEvenStem::calcVertices(otVertices* vertices)
{
if (circleRes <= 2) circleRes = 3;
if (curveRes <= 0) curveRes = 1;
vertexOffset = vertices->getCount();
getCap(vertices, false);
for (int j = 0; j<=curveRes; j++)
{
getCircle(j, vertices);
}
getCap(vertices, true);
}
list<pos_t> scanner::scanlistAroundWalls(pos_t center, const pixelshade_map &scanmap, unsigned int radius)
{
list<pos_t> cups;
if(r!=radius)
update_circle(radius);
list<pos_t> reachables = scanmap.getReachables(getCircle(center),center);
for(auto i:reachables) {
try {
if( WSPACE_IS_CUP(scanmap.const_coordVal(i))) {
cups.push_back(i);
}
} catch (const std::out_of_range& oor) {(void)oor;}
}
return move(cups);
}
Node* CircleModule::evaluate(Context* ctx)
{
NumberValue* rValue=dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
double r=1;
if(rValue) {
r=rValue->getNumber();
}
int f = getFragments(r,ctx);
Polygon c = getCircle(r,f,0);
PrimitiveNode* p = new PrimitiveNode();
if(r > 0) {
p->createPolygon();
for(int i=0; i<f; i++)
p->appendVertex(c.at(i));
}
return p;
}
void drawEllipse(
const geom::Point2D& center,
const geom::Point2D& radius,
int sizeIdx)
{
glPushMatrix();
{
int size;
P2* a = getCircle(sizeIdx, size);
glTranslatef(center.x, center.y, 0.f);
glScalef(radius.x, radius.y, 1.f);
glBegin(GL_LINE_LOOP);
{
for (int i = 0; i != size; ++i)
{
glVertex2f(a[i].x, a[i].y);
}
}
glEnd();
}
glPopMatrix();
}
Node* SphereModule::evaluate(Context* ctx)
{
NumberValue* rValue=dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
Value* centerValue=getParameterArgument(ctx,1);
bool center=true;
if(centerValue)
center=centerValue->isTrue();
double r=1.0;
if(rValue) {
r=rValue->getNumber();
} else {
NumberValue* dValue = dynamic_cast<NumberValue*>(ctx->getArgument(0,"diameter"));
if(dValue)
r=(dValue->getNumber()/2.0);
}
int f = getFragments(r,ctx);
int ringCount=f/2;
QList<Polygon> rings;
for(int i=0; i<ringCount; i++) {
double phi = (M_PI*(i+0.5)) / ringCount;
double r2 = r*sin(phi);
double z = r*cos(phi)+!center*r;
Polygon c = getCircle(r2,f,z);
rings.append(c);
}
PrimitiveNode* p = new PrimitiveNode();
p->createPolygon();
for(int i=0; i<f; i++)
p->appendVertex(rings.at(0).at(i));
for(int i = 0; i < ringCount-1; i++) {
Polygon r1 = rings.at(i);
Polygon r2 = rings.at(i+1);
int r1i = 0, r2i = 0;
while(r1i < f || r2i < f) {
if(r1i >= f)
goto next_r2;
if(r2i >= f)
goto next_r1;
if((double)r1i / f <
(double)r2i / f) {
next_r1:
p->createPolygon();
int r1j = (r1i+1) % f;
p->prependVertex(r1.at(r1i));
p->prependVertex(r1.at(r1j));
p->prependVertex(r2.at(r2i % f));
r1i++;
} else {
next_r2:
p->createPolygon();
int r2j = (r2i+1) % f;
p->appendVertex(r2.at(r2i));
p->appendVertex(r2.at(r2j));
p->appendVertex(r1.at(r1i % f));
r2i++;
}
}
}
p->createPolygon();
for(int i=0; i<f; i++)
p->prependVertex(rings.at(ringCount-1).at(i));
return p;
}
Node* ConeModule::evaluate(Context* ctx)
{
NumberValue* heightValue = dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
NumberValue* r1Value = dynamic_cast<NumberValue*>(getParameterArgument(ctx,1));
NumberValue* r2Value = dynamic_cast<NumberValue*>(getParameterArgument(ctx,2));
Value* centerValue = getParameterArgument(ctx,3);
decimal h=1.0;
if(heightValue)
h=heightValue->getNumber();
decimal r1=0,r2=0;
if(r1Value)
r1=r1Value->getNumber();
if(r2Value)
r2=r2Value->getNumber();
bool center = false;
if(centerValue)
center=centerValue->isTrue();
decimal z1,z2;
z1 = 0.0;
z2 = h;
Fragment fg=getSpecialVariables(ctx);
decimal r=fmax(r1,r2);
int f = fg.getFragments(r);
Polygon* p1 = getCircle(r1,f,z1);
Polygon* p2 = getCircle(r2,f,z2);
QList<Point> c1=p1->getPoints();
QList<Point> c2=p2->getPoints();
PrimitiveNode* p = new PrimitiveNode();
if(r1 > 0) {
p->createPolygon();
foreach(Point pt, c1)
p->appendVertex(pt);
}
if(h==0.0)
return p;
for(int i=0; i<f; i++) {
int j=(i+1)%f;
if(r1 > 0) {
p->createPolygon();
p->appendVertex(c1.at(i));
p->appendVertex(c2.at(i));
p->appendVertex(c1.at(j));
}
if(r2 > 0) {
p->createPolygon();
p->appendVertex(c2.at(i));
p->appendVertex(c2.at(j));
p->appendVertex(c1.at(j));
}
}
if(r2 > 0) {
p->createPolygon();
foreach(Point pt,c2)
p->prependVertex(pt);
}
if(center) {
AlignNode* n=new AlignNode();
n->setCenter(true);
n->addChild(p);
return n;
}
return p;
}
Node* SphereModule::evaluate(Context* ctx)
{
NumberValue* rValue=dynamic_cast<NumberValue*>(getParameterArgument(ctx,0));
Value* centerValue=getParameterArgument(ctx,1);
bool center=true;
if(centerValue)
center=centerValue->isTrue();
decimal r=0.0;
if(rValue) {
r=rValue->getNumber();
} else {
NumberValue* dValue = dynamic_cast<NumberValue*>(ctx->getArgument(0,"diameter"));
if(dValue)
r=(dValue->getNumber()/2.0);
}
if(r==0.0)
return new PointNode();
Fragment fg=getSpecialVariables(ctx);
int f = fg.getFragments(r);
int ringCount=f/2;
decimal h=center?0.0:r;
QList<Polygon> rings;
for(int i=0; i<ringCount; i++) {
decimal phi = (M_PI*(i+0.5)) / ringCount;
decimal r2 = r*sin(phi);
decimal z = r*cos(phi)+h;
Polygon* c = getCircle(r2,f,z);
rings.append(*c);
}
PrimitiveNode* p = new PrimitiveNode();
p->createPolygon();
Polygon top=rings.at(0);
foreach(Point pt, top.getPoints())
p->appendVertex(pt);
for(int i = 0; i < ringCount-1; i++) {
QList<Point> r1 = rings.at(i).getPoints();
QList<Point> r2 = rings.at(i+1).getPoints();
int r1i = 0, r2i = 0;
while(r1i < f || r2i < f) {
if(r2i >= f||(decimal)r1i/f<(decimal)r2i/f) {
p->createPolygon();
int r1j = (r1i+1) % f;
p->prependVertex(r1.at(r1i));
p->prependVertex(r1.at(r1j));
p->prependVertex(r2.at(r2i % f));
r1i++;
} else {
p->createPolygon();
int r2j = (r2i+1) % f;
p->appendVertex(r2.at(r2i));
p->appendVertex(r2.at(r2j));
p->appendVertex(r1.at(r1i % f));
r2i++;
}
}
}
p->createPolygon();
Polygon bottom=rings.at(ringCount-1);
foreach(Point pt, bottom.getPoints())
p->prependVertex(pt);
if(center) {
AlignNode* n=new AlignNode();
n->setCenter(true);
n->addChild(p);
return n;
}
return p;
}
void playback()
{
std::ofstream timing_file("timing_APD.txt");
std::ofstream timing_construct_file("timing_construct_APD.txt");
std::string base_name = "../data/models/Box2D/spider_cinfigs/dump_transform";
std::vector<Polygon> poly = readPolyFile("../data/models/Box2D/nazca_spider77.polys", 3);
for(std::size_t i = 0; i < 7; ++i)
distance_weight[i] = 1;
{
double Ix, Iy;
inertia(poly, Ix, Iy);
double rotation_weight = sqrt(Ix * Ix + Iy * Iy);
distance_weight[0] = 1; distance_weight[1] = 1; distance_weight[2] = rotation_weight;
}
ContactSpaceSE2 contactspace(poly, poly, 0.2 * (getCircle(poly).second + getCircle(poly).second));
SVMLearner learner;
learner.setC(50);
learner.setScaler(contactspace.getScaler());
learner.setUseScaler(true);
learner.setGamma(50);
std::vector<ContactSpaceSampleData> contactspace_samples = contactspace.uniform_sample(100000);
std::ofstream scaler_file("scaler.txt");
scaler_file << contactspace.getScaler() << std::endl;
learner.learn(contactspace_samples, contactspace.active_data_dim());
learner.save("model.txt");
std::cout << empiricalErrorRatio(contactspace_samples, learner) << " " << errorRatioOnGrid(contactspace, learner, 20) << std::endl;
Collider2D collider(poly, poly);
// flann::HierarchicalClusteringIndex<ContactSpaceSE2::DistanceType>* query_index = learner.constructIndexOfSupportVectorsForQuery<ContactSpaceSE2, flann::HierarchicalClusteringIndex, flann::HierarchicalClusteringIndexParams>();
int knn_k = 2; // 50;
std::vector<ContactSpaceSampleData> support_samples;
learner.collectSupportVectors(support_samples);
ExtendedModel<ContactSpaceSE2, flann::HierarchicalClusteringIndex> extended_model = constructExtendedModelForModelDecisionBoundary<ContactSpaceSE2, SVMLearner, flann::HierarchicalClusteringIndex, flann::HierarchicalClusteringIndexParams>(contactspace, learner, support_samples, 0.01, knn_k);
for(std::size_t i = 1001; i < 9999; ++i)
{
std::stringstream ss;
ss << i;
std::string ret;
ss >> ret;
std::size_t len = ret.length();
for(std::size_t j = 0; j < 4 - len; ++j)
ret = "0" + ret;
std::string filename = base_name + ret + ".txt";
std::string PD_file_name= std::string("PD_APD") + ret + ".txt";
std::ofstream PD_file(PD_file_name.c_str());
std::vector<std::vector<std::pair<std::string, DataVector> > > frame = readDumpFile(filename);
double timing_per_frame = 0;
for(std::size_t j = 0; j < frame.size(); ++j)
{
std::cout << i << " " << j << std::endl;
if(frame[j][0].first == "Wall" || frame[j][1].first == "Wall") continue;
boost::timer t;
DataVector q = relative2D(frame[j][0].second, frame[j][1].second);
if(collider.isCollide(q))
{
// QueryResult PD_result = PD_query(learner, contactspace, query_index, q);
QueryResult PD_result = PD_query(learner, contactspace, extended_model.index, extended_model.samples, q);
PD_file << PD_result.PD << " ";
}
else
{
PD_file << 0 << " ";
}
timing_per_frame += t.elapsed();
}
timing_file << timing_per_frame << " ";
timing_file.flush();
PD_file.flush();
}
}
//for any one-time only initialization of the
// virtual world before any rendering takes place
// BUT after OpenGL has been initialized
void init()
{
glEnable(GL_LIGHTING);
/*
points = {
{{ -4.0f, -5.0f }}, {{ -4.0f, 5.0f }},
{{ 0.0f, 7.0f }}, {{ 4.0f, 5.0f }},
{{ 4.0f, -5.0f }}, {{ 0.0f, -7.0f }}
};
*/
points3d = {
{{ -4.0f, -5.0f,5.0f }},
{{ 4.0f, 5.0f,5.0f }},
{{ 8.0f, 7.0f,5.0f }},
{{ 12.0f, 5.0f,5.0f }},
{{ 16.0f, -5.0f,5.0f }},
{{ 20.0f, -7.0f,5.0f }}
};
auto circle = getCircle(2, 10);
for (auto &v : circle) points.push_back({{ v[0], v[2] }});
//spring:
points3d = generateSpline(-50, 50, 150,
[](float z)->float { return sin(z/2.0) * 15; },
[](float x)->float { return cos(x/2.0) * 15; },
[](float y)->float { return y; });
// heart:
/*
points3d = generateSpline(-50, 50, 150,
[](float z)->float {
float t = z/5.0;
return 16 * sin(t) * sin(t) * sin(t);
},
[](float x)->float {
float t = x/5.0;
return 13 * cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t);
});
*/
extrude = new Extrusion(points);
extrude->setDepth(8);
loft = new Loft(points, points3d);
//Low-polygons dragon (5835 triangles)
mymodelloader.load("data/model_lowpolygonstanforddragon.txt",100);
deer = new Mesh("data/deer.obj");
deer->setFlatColor({{.8, .2, .8}});
deer->setTranslateX(10.5f);
deer->setScale(0.5f);
elephant = new Mesh("data/elephant-triangulated.obj");
elephant->setFlatColor({{ .8, .1, .15 }});
elephant->setTranslateX(-10.5f);
elephant->setRotateY(-45.0f);
pts = getCircle(8, 7);
vec3 startNormal = {{ 0, 1, 0 }};
vec3 targetNormal = {{ 0.3333, 0.3333, 0.3333 }};
mat3 rotationMatrix = getRotationMatrix(startNormal, targetNormal);
for (auto &p : pts) {
ptsTransformed.push_back(mult(rotationMatrix, p));
}
//Try this:
//High-polygons dragon (original model of Stanford Dragon)
// (871414 triangles) will take some minutes for it to get loaded
//mymodelloader.load("data/model_highpolygonstanforddragon.txt",100);
//mymodelloader.load("data/model_rose.txt", 0.2);
//mymodelloader.load("data/model_shuttle.txt", 0.1);
timeold = glutGet(GLUT_ELAPSED_TIME);
}
Snowflake::Snowflake(Point p, Terrain* t, Camera* camera) : Bone(getCircle())
{
this->position = p;
this->terrain = t;
this->camera = camera;
}
Snowflake::Snowflake(Terrain* t, Camera* camera) : Bone(getCircle())
{
this->terrain = t;
this->position = getRandomPosition(false);
this->camera = camera;
}
unordered_set<pos_t> scanner::getCircle(const pos_t ¢er)
{ return move(getCircle(center,r)); }
