int main(int argc, char** argv)
{
// Get geometric tolerance from the argument list.
double epsge = atof(argv[1]);
// Read curve file
//string inp_curve_filename("approj_curve.g2");
//string inp_curve_filename("const_u_paramcurve.g2");
string inp_curve_filename("const_v_paramcurve.g2");
ifstream cfile(inp_curve_filename.c_str());
if (!cfile) {
cerr << "\nFile error. Could not open file: " << inp_curve_filename.c_str() << endl;
return 1;
}
shared_ptr<SplineCurve> curve(new SplineCurve);
ObjectHeader header;
cfile >> header;
if (!header.classType() == SplineCurve::classType()) {
THROW("Object type is NOT SplineCurve.");
}
cfile >> (*curve);
cfile.close();
shared_ptr<ParamCurve> pcurve = curve;
// Read surface file
string inp_surf_filename("surface.g2");
ifstream sfile(inp_surf_filename.c_str());
if (!sfile) {
cerr << "\nFile error. Could not open file: " << inp_surf_filename.c_str() << endl;
return 1;
}
shared_ptr<SplineSurface> surf(new SplineSurface);
sfile >> header;
if (!header.classType() == SplineSurface::classType()) {
THROW("Object type is NOT SplineSurface.");
}
sfile >> (*surf);
sfile.close();
shared_ptr<ParamSurface> psurf = surf;
// Create projection curves
shared_ptr<SplineCurve> proj_cv;
shared_ptr<SplineCurve> par_cv;
CurveCreators::projectCurve(pcurve, psurf, epsge, proj_cv, par_cv);
// Write 3D space curve to file.
ofstream scvout("proj_space_curve.g2");
//proj_cv->writeStandardHeader(scvout);
scvout << "100 1 0 4 0 255 0 255" << endl; // write header. Green curve
scvout << *proj_cv; // write space spline curve data.
scvout.close();
// Write 2D parameter curve to file.
ofstream pcvout("proj_param_curve.g2");
par_cv->writeStandardHeader(pcvout); // write header
pcvout << *par_cv; // write parameter spline curve data.
pcvout.close();
return 0;
}
void Outstation::appendVariableSizedObject( const ObjectHeader& h,
const DnpObject& o)
{
stats.logNormal( h.str( strbuf, sizeof(strbuf)));
h.encode( txFragment);
appendUINT16( txFragment, o.size());
o.encode( txFragment);
}
int main(int argc, char** argv)
{
string inp_curve_filename("approj_curve.g2");
Point location(0.0, 5.0, 200.0);
Point axis_dir(1.0, 0.0, 0.0);
cout << "\nRunning program '" << argv[0] << "' with spline curve filename= '"
<< inp_curve_filename.c_str() << "'." << endl;
// Read spline curve file
ifstream cfile(inp_curve_filename.c_str());
if (!cfile) {
cerr << "\nFile error. Could not open file: " << inp_curve_filename.c_str()
<< endl;
return 1;
}
shared_ptr<SplineCurve> spline_curve(new SplineCurve);
ObjectHeader header;
cfile >> header;
if (!header.classType() == SplineCurve::classType()) {
THROW("Object type is NOT SplineCurve.");
}
cfile >> (*spline_curve);
cfile.close();
// Print some curve information
Point pnt3d(3);
spline_curve->point(pnt3d, spline_curve->startparam());
cout << "\nSplineCurve: Dim= " << spline_curve->dimension()
<< "\nStart. Param= " << spline_curve->startparam() << " Point= "
<< pnt3d << endl;
spline_curve->point(pnt3d, spline_curve->endparam());
cout << "End. Param= " << spline_curve->endparam() << " Point= "
<< pnt3d << endl;
cout << "Bounding box = " << spline_curve->boundingBox() << endl;
// Create the SurfaceOfRevolution object.
SurfaceOfRevolution surf_of_revolution(location, axis_dir, spline_curve);
cout << "\nSurface: Dim= " << surf_of_revolution.dimension() << endl;
cout << "Bounding box = " << surf_of_revolution.boundingBox() << endl;
cout << "Location = " << surf_of_revolution.getLocation() << endl;
cout << "Axis direction = " << surf_of_revolution.getAxisDir() << endl;
// Make a SplineSurface representation and write to file.
SplineSurface* spline_surf = surf_of_revolution.geometrySurface();
ofstream fout("surface_of_revolution.g2");
spline_surf->writeStandardHeader(fout);
spline_surf->write(fout);
fout.close();
// cout << "\nOpen the files 'surface_of_revolution.g2' and 'approj_curve.g2'"
// << " in 'goview' to look at the results.\n" << endl;
delete spline_surf;
return 0;
}
int main(int argc, char** argv)
{
ASSERT(argc >= 2);
ifstream file(argv[1]);
ObjectHeader head;
SplineSurface sf;
SplineCurve cv;
file >> head;
if (head.classType() == SplineSurface::classType()) {
file >> sf;
} else if (head.classType() == SplineCurve::classType()) {
int main(int argc, char** argv)
{
if (argc != 2 && argc != 4)
{
std::cout << "Usage; infile (nmb u pts) (nmb v pts)" << std::endl;
return -1;
}
std::ifstream infile(argv[1]);
ObjectHeader head;
head.read(infile);
BoundedSurface gosf;
gosf.read(infile);
const RectDomain& dom = gosf.containingDomain();
double start_u = dom.umin();
double end_u = dom.umax();
double start_v = dom.vmin();
double end_v = dom.vmax();
int nmb_u = 20, nmb_v = 20;
if (argc == 4)
{
nmb_u = atoi(argv[2]);
nmb_v = atoi(argv[3]);
}
double del_u = (end_u - start_u)/(double)(nmb_u-1);
double del_v = (end_v - start_v)/(double)(nmb_v-1);
vector<Point> inside;
int ki, kj;
double u, v;
for (v=start_v, ki=0; ki<nmb_v; v+=del_v, ki++)
for (u=start_u, kj=0; kj<nmb_u; u+=del_u, kj++)
{
Point curr;
if (!gosf.inDomain(u,v))
continue;
gosf.point(curr, u, v);
inside.push_back(curr);
}
std::ofstream out_file("inside_pts.g2");
out_file << "400 1 0 4 255 0 0 255" << std::endl;
out_file << inside.size() << std::endl;
for (ki=0; ki < (int)inside.size(); ki++)
{
out_file << inside[ki][0] << " " << inside[ki][1] << " ";
out_file << inside[ki][2] << std::endl;
}
}
Object* Thread::unlock_locks(STATE, GCToken gct, CallFrame* calling_environment) {
Thread* self = this;
OnStack<1> os(state, self);
LockedObjects& los = self->vm_->locked_objects();
for(LockedObjects::iterator i = los.begin();
i != los.end();
++i) {
ObjectHeader* locked = *i;
if(locked != self) {
locked->unlock_for_terminate(state, gct, calling_environment);
}
}
los.clear();
return cNil;
}
int main(int argc, char** argv)
{
if (argc != 6) {
cout << "Usage: spline_sf x0 y0 z0 r" << endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream filein(argv[1]);
if (filein.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
double x0 = atof(argv[2]);
double y0 = atof(argv[3]);
double z0 = atof(argv[4]);
double r = atof(argv[5]);
header.read(filein);
shared_ptr<ParamSurface> surf(new SplineSurface());
surf->read(filein);
filein.close();
Point center(x0, y0, z0);
shared_ptr<SphereInt> sphere(new SphereInt(center, r));
// double dummy_tol = 1e-03; // @@sbr Not yet used.
shared_ptr<ParamObjectInt> par_obj_int(new ParamSurfaceInt(surf));
shared_ptr<AlgObjectInt> alg_obj_int = sphere;
shared_ptr<GeoTol> aepsge(new GeoTol(1.e-6));
//IntersectorAlgPar int_alg_par(alg_obj_int, par_obj_int, aepsge);
IntersectorAlgPar int_alg_par(sphere, par_obj_int, aepsge);
int_alg_par.compute();
std::vector<shared_ptr<IntersectionPoint> > int_points;
std::vector<shared_ptr<IntersectionCurve> > int_curves;
int_alg_par.getResult(int_points, int_curves);
cout << "IntPoints found: " << int_points.size() << endl;
cout << "IntCurves found: " << int_curves.size() << endl;
return 0;
}
//-*****************************************************************************
void WriteIdentifier( const ObjectHeader &ohead )
{
std::string name = ohead.getFullName();
char* nameArray[] = { const_cast<char*>( name.c_str() ), RI_NULL };
RiAttribute(const_cast<char*>( "identifier" ), const_cast<char*>( "name" ),
nameArray, RI_NULL );
}
int main(int argc, char* argv[] )
{
if (argc != 5)
{
std::cout << "Usage: " << argv[0]
<< " input_ellipse tmin tmax output_subcurve" << endl;
return -1;
}
// Open input surface file
ifstream is(argv[1]);
double tmin(atof(argv[2]));
double tmax(atof(argv[3]));
ofstream os(argv[4]);
if (is.bad())
{
std::cout << "Bad or no input filename" << std::endl;
return -1;
}
// Read surface from file
ObjectHeader head;
Ellipse ellipse; // Typically: centre, dir, normal, r1, r2.
is >> head;
ASSERT(head.classType() == Ellipse::classType());
is >> ellipse;
if (tmin < ellipse.startparam() || tmax > ellipse.endparam())
{
std::cout << "tmin or tmax outside domain of ellipse." << std::endl;
return -1;
}
std::cout << "Writing to file." << std::endl;
// Extract subcurve, write to file.
ellipse.setParamBounds(tmin, tmax);
shared_ptr<SplineCurve> sub_ellipse(ellipse.geometryCurve());
sub_ellipse->writeStandardHeader(os);
sub_ellipse->write(os);
return 0;
}
int main(int argc, char** argv)
{
if (argc < 3) {
cerr << "Usage: " << argv[0] << " u_res v_res" << endl;
return 1;
}
int ures = atoi(argv[1]);
int vres = atoi(argv[2]);
ObjectHeader head;
cin >> head;
ASSERT(head.classType() == SplineSurface::classType());
SplineSurface sf;
cin >> sf;
vector<double> points;
vector<double> param_u;
vector<double> param_v;
sf.gridEvaluator(ures, vres, points, param_u, param_v);
RectGrid grid(ures, vres, sf.dimension(), &points[0]);
grid.writeStandardHeader(cout);
grid.write(cout);
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
std::cout << "Usage: sfs_file (.g2) repaired_sfs_file (.g2)" << std::endl;
return -1;
}
std::ifstream filein(argv[1]); // Input bd sfs (may contain other objects).
std::ofstream fileout(argv[2]); // Fixed bd sfs (and unaltered other objects).
// For BoundedSurface we may choose to recreate all the boundary parameter curves.
const bool recreate_par_cvs = true;
if (recreate_par_cvs)
{
cout << "Recreating all parameter curve for CurveOnSurface." << endl;
}
// Create the default factory
GoTools::init();
ObjectHeader header;
int num_bd_sfs = 0;
int num_bd_sfs_fixed = 0;
int num_bd_sfs_fix_failed = 0;
int obj_id = 0;
while (filein)
{
std::cout << "Object number: " << obj_id << std::endl;
try {
header.read(filein);
}
catch (...)
{
MESSAGE("Failed reading the Header!");
break; // Assuming we are either done or the rest of the file is garbage ...
}
shared_ptr<GeomObject> geom_obj(Factory::createObject(header.classType()));
try
{
geom_obj->read(filein);
}
catch (...)
{
MESSAGE("Failed reading the GeomObject!");
}
if (geom_obj->instanceType() != Class_BoundedSurface)
{
cout << "Writing to file an object of type :" << geom_obj->instanceType()<< endl;
geom_obj->writeStandardHeader(fileout);
geom_obj->write(fileout);
} else if (geom_obj->instanceType() == Class_BoundedSurface)
{
++num_bd_sfs;
BoundedSurface* bd_sf = dynamic_cast<BoundedSurface*>(geom_obj.get());
double epsgeo = 1.5e-02;// bd_sf->getEpsGeo(); // The smallest for all the loops.
int valid_state = 0;
bool is_valid = bd_sf->isValid(valid_state);
#ifndef NDEBUG
std::ofstream debug("tmp/debug.g2");
ParamSurface* under_sf = bd_sf->underlyingSurface().get();
under_sf->writeStandardHeader(debug);
under_sf->write(debug);
for (int ki = 0; ki < bd_sf->numberOfLoops(); ++ki)
{
shared_ptr<CurveLoop> loop = bd_sf->loop(ki);
for (size_t kj = 0; kj < loop->size(); ++kj)
{
shared_ptr<ParamCurve> cv = (*loop)[kj];
if (cv->instanceType() == Class_CurveOnSurface)
{
shared_ptr<CurveOnSurface> cv_on_sf =
dynamic_pointer_cast<CurveOnSurface, ParamCurve>(cv);
if (cv_on_sf->parameterCurve() != NULL) {
shared_ptr<SplineCurve> pcv =
dynamic_pointer_cast<SplineCurve, ParamCurve>
(cv_on_sf->parameterCurve());
if (pcv.get() != NULL)
SplineDebugUtils::writeSpaceParamCurve(*pcv, debug, 0.0);
else
{
cv_on_sf->parameterCurve()->writeStandardHeader(debug);
cv_on_sf->parameterCurve()->write(debug);
}
}
if (cv_on_sf->spaceCurve() != NULL)
{
cv_on_sf->spaceCurve()->writeStandardHeader(debug);
cv_on_sf->spaceCurve()->write(debug);
}
}
else
{
cv->writeStandardHeader(debug);
cv->write(debug);
}
}
}
double debug_val = 0.0;
#endif
if (valid_state < 0)//== -2)
{
if (bd_sf->underlyingSurface()->instanceType() == Class_Cylinder)
{ // Special treatment checking for par cvs crossing the seem.
bool fixed = fixParCvCrossingCylinderSeem(bd_sf);
if (fixed)
{
MESSAGE("A parameter curve crossed the seem, fixed!");
is_valid = bd_sf->isValid(valid_state);
if (is_valid)
{
cout << "Success! obj_id = " << obj_id << endl;
++num_bd_sfs_fixed;
continue;
}
}
}
vector<CurveLoop> bd_loops = bd_sf->allBoundaryLoops();
//We must create missing parameter curves project space curves).
for (size_t ki = 0; ki < bd_loops.size(); ++ki)
{
for (size_t kj = 0; kj < bd_loops[ki].size(); ++kj)
{
try
{
if (bd_loops[ki][kj]->instanceType() == Class_CurveOnSurface)
{
CurveOnSurface* cv_on_sf = dynamic_cast<CurveOnSurface*>(bd_loops[ki][kj].get());
shared_ptr<ParamCurve> empty_par_cv;
if (recreate_par_cvs)
{
cout << "Removing parameter curve!" << endl;
cv_on_sf->setParameterCurve(empty_par_cv);
}
cv_on_sf->ensureParCrvExistence(epsgeo);
}
}
catch (...)
{
MESSAGE("Failed projecting space curve!");
}
}
}
is_valid = bd_sf->isValid(valid_state);
if (is_valid)
{
MESSAGE("Success!");
}
}
if (!is_valid)
{
MESSAGE("Trying to fix the BoundedSurface!");
double max_loop_gap = -1.0;
bool success = bd_sf->fixInvalidSurface(max_loop_gap);
if (success)
{
cout << "Success! ki = " << obj_id << endl;
++num_bd_sfs_fixed;
bd_sf->writeStandardHeader(fileout);
bd_sf->write(fileout);
}
else
{
is_valid = bd_sf->isValid(valid_state);
MESSAGE("Failed fixing bd_sf! Status: " << valid_state <<
". Object id = " << obj_id);
++num_bd_sfs_fix_failed;
if (valid_state == -1)
{ // This means we may need to replace the epsgeo with a larger value.
// @@sbr201310 Replace epsgeo with larger value!
double epsgeo = bd_sf->getEpsGeo();
// We use the same tolerance for all the loops.
int num_loops = bd_sf->numberOfLoops();
double global_max_loop_sf_dist = 0.0;
int num_samples = 100; // @@sbr201310 The number of samples should not be a user input.
for (int ki = 0; ki < num_loops; ++ki)
{
double max_loop_sf_dist = bd_sf->maxLoopSfDist(ki, num_samples);
if (max_loop_sf_dist > global_max_loop_sf_dist)
{
global_max_loop_sf_dist = max_loop_sf_dist;
}
}
double new_epsgeo = 1.1*global_max_loop_sf_dist;
std::cout << "epsgeo: " << epsgeo << ", new_epsgeo: " << new_epsgeo << std::endl;
for (int ki = 0; ki < num_loops; ++ki)
{
if (bd_sf->loop(ki)->getSpaceEpsilon() < new_epsgeo)
{
bd_sf->loop(ki)->setSpaceEpsilon(new_epsgeo);
}
}
// /// Get a shared pointer to a specific boundary loop
// shared_ptr<CurveLoop> loop(int idx)
// { return boundary_loops_[idx]; }
// std::vector<CurveLoop> all_bd_loops = bd_sf->absolutelyAllBoundaryLoops();
// for (size_t ki = 0; ki < all_bd_loops.size(); ++ki)
// {
// if (all_bd_loops[ki].getSpaceEpsilon() < new_epsgeo)
// {
// all_bd_loops[ki].setSpaceEpsilon(new_epsgeo);
// }
// }
// shared_ptr<ParamSurface> under_sf = bd_sf->underlyingSurface();
// bd_sf = shared_ptr<BoundedSurface>
// (new BoundedSurface(under_sf, all_bd_loops, new_epsgeo));
bd_sf->analyzeLoops();
is_valid = bd_sf->isValid(valid_state);
std::cout << "valid_state after tolerance change: " << valid_state << std::endl;
if (is_valid)
{
--num_bd_sfs_fix_failed;
++num_bd_sfs_fixed;
}
bd_sf->writeStandardHeader(fileout);
bd_sf->write(fileout);
}
else
{
// We write to file the underlying surfaces and the space curves.
shared_ptr<ParamSurface> under_sf = bd_sf->underlyingSurface();
under_sf->writeStandardHeader(fileout);
under_sf->write(fileout);
vector<CurveLoop> bd_loops = bd_sf->allBoundaryLoops();
for (size_t ki = 0; ki < bd_loops.size(); ++ki)
{
for (size_t kj = 0; kj < bd_loops[ki].size(); ++kj)
{
shared_ptr<ParamCurve> par_cv = bd_loops[ki][kj];
if (par_cv->instanceType() == Class_CurveOnSurface)
{
CurveOnSurface* cv_on_sf = dynamic_cast<CurveOnSurface*>(par_cv.get());
if (cv_on_sf->spaceCurve())
{
cv_on_sf->spaceCurve()->writeStandardHeader(fileout);
cv_on_sf->spaceCurve()->write(fileout);
}
else
{
MESSAGE("Missing space curve!");
}
}
else
{
MESSAGE("Unexpected curve type!");
}
}
}
}
}
}
else
{
bd_sf->writeStandardHeader(fileout);
bd_sf->write(fileout);
}
}
// else
// {
// geom_obj->writeStandardHeader(fileout);
// geom_obj->write(fileout);
// }
++obj_id;
}
std::cout << "num_bd_sfs: " << num_bd_sfs << ", num_bd_sfs_fixed: " << num_bd_sfs_fixed <<
", num_bd_sfs_fix_failed: " << num_bd_sfs_fix_failed << std::endl;
}
int main(int argc, char** argv)
{
// Read the surface from a file in Go-format.
string filename("degenerate_sf.g2");
cout << "\nProgram " << argv[0] << " using file " << filename.c_str() << endl;
ifstream file(filename.c_str());
if (!file) {
cerr << "\nFile error. Could not open file: " << filename.c_str() << endl;
return 1;
}
ObjectHeader head;
SplineSurface surf;
file >> head;
if (!head.classType() == SplineSurface::classType()) {
THROW("Object type is NOT SplineSurface.");
}
file >> surf;
file.close();
// Read the points from a file. xyz-coordinates.
string point_filename("inp_degen_surf_close_points.dat");
ifstream pfile(point_filename.c_str());
if (!pfile) {
cerr << "\nFile error. Could not open file: " << point_filename.c_str() << endl;
return 1;
}
vector<Point> points;
while (1) {
Point p(3);
pfile >> p;
if (!pfile) break;
points.push_back(p);
}
pfile.close();
int N = (int)points.size();
cout << "\nProgram '" << argv[0] << "' using input files '" << filename.c_str()
<< "' and '" << point_filename.c_str()
<< ", and output file 'degen_surf_close_points.g2'." << endl;
// Find the points on the surface closest to these points.
double close_u; // Closest point's u parameter.
double close_v; // Closest point's v parameter.
Point close_pt(3); // Closest point's coordinates.
double close_dist; // Distance between the two points.
double epsilon = 1e-8; // Parameter tolerance
// Write to file vectors from a point to the closest point on the surface.
ofstream fout2("degenerate_sf_close_points.g2");
// Class_LineCloud=410 MAJOR_VERSION=1 MINOR_VERSION=1 auxillary data=4
// The four auxillary data values defines the colour (r g b alpha)
fout2 << "410 1 0 4 255 0 0 255" << endl; // Header.
fout2 << N << endl;
// Find closest point using the whole surface. (The two last arguments
// 'RectDomain* domain_of_interest' and 'double *seed' are by default
// equal to 0).
cout << "\nClosest points from inputfile points to points on the surface ";
for (int i=0; i<N; ++i) {
surf.closestPoint(points[i], close_u, close_v, close_pt, close_dist,
epsilon);
fout2 << points[i] << ' ' << close_pt << endl; // write vector
cout << "Point: " << points[i] << " Closest point: " << close_pt
<< "\nParameter values= " << close_u << " , " << close_v
<< " Closest distance= " << close_dist << endl;
}
fout2.close();
// Find closest point from points on the surface. Should be 0 + some tolerance.
cout << "\nClosest points from points on the surface." << endl;
const int nsp = 9;
double du = (surf.endparam_u() - surf.startparam_u()) / (nsp-1);
double dv = (surf.endparam_v() - surf.startparam_v()) / (nsp-1);
cout << "Parameter u from " << surf.startparam_u() << " to " << surf.endparam_u()
<< " step " << du << endl;
cout << "Parameter v from " << surf.startparam_v() << " to " << surf.endparam_v()
<< " step " << dv << endl;
double max_dist = 0.0;
Point point;
for (double v=surf.startparam_v(); v<=surf.endparam_v(); v += dv) {
for (double u=surf.startparam_u(); u<=surf.endparam_u(); u += du) {
surf.point(point, u, v); // interpolate at u,v
surf.closestPoint(point, close_u, close_v, close_pt, close_dist,
epsilon);
#ifdef DEBUG
cout << "\n Point: " << point << "\nClosest point: " << close_pt
<< "\nParameter values= " << close_u << " , " << close_v
<< " Closest distance= " << close_dist << endl;
#endif
}
max_dist = std::max(close_dist, max_dist);
}
cout << "\nMaximum distance between an interpolated point and the "
<< "corresponding input point is " << max_dist << '\n' << endl;
}
int main(int argc, char** argv)
{
if (argc != 4) {
cout << "Usage: test_CvCvIntersector FileCv1 FileCv2 aepsge"
<< endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream input1(argv[1]);
if (input1.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input1);
shared_ptr<ParamCurve> curve1(new SplineCurve());
curve1->read(input1);
input1.close();
// Read the second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
shared_ptr<ParamCurve> curve2(new SplineCurve());
curve2->read(input2);
input2.close();
double aepsge;
aepsge = atof(argv[3]);
// cout << "\nFile : " << argv[2] << " Parameter range u: "
// << curve1->startparam_u() <<" " << curve1->endparam_u()
// << " Parameter range v: " << curve1->startparam_v() <<" "
// << curve1->endparam_v();
// cout << "\nFile : " << argv[2] << " Parameter range u: "
// << curve2->startparam_u() <<" " << curve2->endparam_u()
// << " Parameter range v: " << curve2->startparam_v() <<" "
// << curve2->endparam_v() << endl;
shared_ptr<ParamGeomInt> scurveint1 =
shared_ptr<ParamGeomInt>(new SplineCurveInt (curve1));
shared_ptr<ParamGeomInt> scurveint2 =
shared_ptr<ParamGeomInt>(new SplineCurveInt (curve2));
CvCvIntersector cvcvintersect (scurveint1, scurveint2, aepsge);
cvcvintersect.compute();
std::vector<shared_ptr<IntersectionPoint> > intpts;
std::vector<shared_ptr<IntersectionCurve> > intcrv;
cvcvintersect.getResult(intpts, intcrv);
printf("Number of points: %d \n", int(intpts.size()));
printf("Number of curves: %d \n", int(intcrv.size()));
int ki, kj;
for (ki=0; ki < int(intpts.size()); ki++) {
std::vector<double> par = intpts[ki]->getPar();
for (kj=0; kj<int(par.size()); kj++)
std::cout << par[kj] << " ";
std::cout << std::endl;
}
return 0;
}
int main(int argc, char** argv)
{
if (argc != 7) {
cout << "Usage: test_curveSplineCurveInt FILE1 FILE2 "
<< "pstart1 pstart2 pstop1 pstop2"
<< endl;
return 0;
}
double pstart1, pstart2, pstop1, pstop2;
pstart1 = atof(argv[3]);
pstart2 = atof(argv[4]);
pstop1 = atof(argv[5]);
pstop2 = atof(argv[6]);
ObjectHeader header;
// Read first curve from file
ifstream input(argv[1]);
if (input.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input);
shared_ptr<SplineCurve> curve1(new SplineCurve());
curve1->read(input);
input.close();
// Read second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
shared_ptr<SplineCurve> curve2(new SplineCurve());
curve2->read(input2);
input.close();
// int prec = std::cout.precision(16);
cout << "\nFile : " << argv[1] << " Parameter range: "
<< curve1->startparam() <<" " << curve1->endparam();
cout << " Start: " << pstart1 << " Stop: " << pstop1;
cout << "\nFile : " << argv[2] << " Parameter range: "
<< curve2->startparam() <<" " << curve2->endparam();
cout << " Start: " << pstart2 << " Stop: " << pstop2 << endl;
const double eps = 1.e-4;
cout << " Eps= " << eps << endl;
// SplineCurveInt sci1(curve1);
// SplineCurveInt sci2(curve2);
// int istat;
// istat = sci1.checkCoincidence(pstart1, pstop1, eps, &sci2,
// pstart2, pstop2);
// cout << "\nistat = " << istat;
// if (istat==0)
// cout << " Curves are not coinciding." << endl;
// else
// cout << " Curves are coinciding." << endl;
// std::cout.precision(prec);
return 0;
}
int main(int argc, char** argv)
{
if (argc != 4) {
cout << "Usage: " << argv[0] << " FileSf FileCv aepsge" << endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream input1(argv[1]);
if (input1.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input1);
SplineSurface surf;
surf.read(input1);
input1.close();
// Read the second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
SplineCurve curve;
curve.read(input2);
input2.close();
double aepsge;
aepsge = atof(argv[3]);
// Set up and run the intersection algorithm
SISLCurve* pcurve = Curve2SISL(curve);
SISLSurf* psurf = GoSurf2SISL(surf);
double astart1 = curve.startparam();
double estart2[] = { surf.startparam_u(), surf.startparam_v() };
double aend1 = curve.endparam();
double eend2[] = { surf.endparam_u(), surf.endparam_v() };
cout << "astart1 = " << astart1 << endl
<< "estart2[] = { " << estart2[0] << ", "
<< estart2[1] << " }" << endl
<< "aend1 = " << aend1 << endl
<< "eend2[] = { " << eend2[0] << ", "
<< eend2[1] << " }" << endl;
double anext1 = astart1;
double enext2[] = { estart2[0], estart2[1] };
// double anext1 = 0.0;
// double enext2[] = { 2.0, 0.0 };
cout << "anext1 = " << anext1 << endl
<< "enext2[] = { " << enext2[0] << ", "
<< enext2[1] << " }" << endl;
double cpos1;
double gpos2[2];
int jstat = 0;
cout << "jstat = " << jstat << endl;
s1772(pcurve, psurf, aepsge, astart1, estart2, aend1, eend2,
anext1, enext2, &cpos1, gpos2, &jstat);
// Write the results
cout << "Results s1772:" << endl
<< "jstat = " << jstat << endl
<< "cpos1 = " << cpos1 << endl
<< "gpos2[] = { " << gpos2[0] << ", "
<< gpos2[1] << " }" << endl;
return 0;
}
//===========================================================================
vector<double>
TrimCrvUtils::readTrimPoints(ifstream& filein, Point& translate_vec)
//===========================================================================
{
vector<double> pts_2d;
translate_vec = Point(0.0, 0.0, 0.0);
const bool translate_model = true;//false;
if (translate_model)
{
MESSAGE("Switched off translation of the model to the origin!");
}
ObjectHeader header;
header.read(filein);
if (header.classType() == Class_PointCloud)
{
PointCloud3D pt_cloud;
pt_cloud.read(filein);
if (translate_model)
{
translateToOrigin(pt_cloud, translate_vec);
}
const int dim = pt_cloud.dimension();
assert(dim == 3);
const int num_pts = pt_cloud.numPoints();
vector<double> pts_3d(pt_cloud.rawData(), pt_cloud.rawData() + dim*num_pts);
pts_2d.resize(num_pts*2);
for (int ki = 0; ki < num_pts; ++ki)
{
pts_2d[ki*2] = pts_3d[ki*dim];
pts_2d[ki*2+1] = pts_3d[ki*dim+1];
}
}
else if (header.classType() == Class_LineCloud)
{
LineCloud line_cloud;
line_cloud.read(filein);
if (translate_model)
{
translateToOrigin(line_cloud, translate_vec);
}
// Assuming the dimension is 3. Which is a requirement by LineCloud, strangely enough.
const int dim = 3;
const int num_lines = line_cloud.numLines();
const int num_pts = num_lines + 1;
pts_2d.resize(num_pts*2);
const double* raw_data = line_cloud.rawData();
pts_2d[0] = raw_data[0];
pts_2d[1] = raw_data[1];
for (int ki = 1; ki < num_pts; ++ki)
{
pts_2d[ki*2] = raw_data[ki*dim*2-dim];
pts_2d[ki*2+1] = raw_data[ki*dim*2-dim+1];
}
}
else
{
MESSAGE("Object type " << header.classType() << " is not supported.");
}
return pts_2d;
}
int main(int argc, char** argv)
{
#ifndef _MSC_VER
setenv("DEBUG", "1", 1);
setenv("DEBUG_PAR", "1", 1);
setenv("DEBUG_FINISH", "1", 1);
setenv("DEBUG_IMPL", "1", 1);
setenv("SUBDIV_SFCV", "1", 1);
if (getenv("DEBUG") && (*getenv("DEBUG"))=='1')
cout << "DEBUG=1" << endl;
if (getenv("DEBUG_PAR") && (*getenv("DEBUG_PAR"))=='1')
cout << "DEBUG_PAR=1" << endl;
if (getenv("DEBUG_FINISH") && (*getenv("DEBUG_FINISH"))=='1')
cout << "DEBUG_FINISH=1" << endl;
if (getenv("DEBUG_IMPL") && (*getenv("DEBUG_IMPL"))=='1')
cout << "DEBUG_IMPL=1" << endl;
if (getenv("SUBDIV_SFCV") && (*getenv("SUBDIV_SFCV"))=='1')
cout << "SUBDIV_SFCV=1" << endl;
#endif // _MSC_VER
if (argc != 5 && argc != 6) {
cout << "Usage: test_CvCvIntersector FileSf FileCv"
<< " aepsge switch-order (OutputFile)" << endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream input1(argv[1]);
if (input1.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input1);
shared_ptr<ParamSurface> surf(new SplineSurface());
surf->read(input1);
input1.close();
// Read the second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
shared_ptr<ParamCurve> curve(new SplineCurve());
curve->read(input2);
input2.close();
double aepsge;
aepsge = atof(argv[3]);
int seq;
seq = atoi(argv[4]);
ofstream tmpout;
if (argc == 6)
tmpout.open(argv[5]);
ostream& out = (argc == 6) ? tmpout : cout;
out << setprecision(8);
// Setup the SplineSurfaceInt and SplineCurveInt objects
shared_ptr<ParamGeomInt> ssurfint =
shared_ptr<ParamGeomInt>(new SplineSurfaceInt (surf));
shared_ptr<ParamGeomInt> scurveint =
shared_ptr<ParamGeomInt>(new SplineCurveInt (curve));
// Set up and run the intersection algorithm
if (seq)
{
SfCvIntersector sfcvintersect(scurveint, ssurfint, aepsge);
sfcvintersect.compute();
// Get the results
vector<shared_ptr<IntersectionPoint> > intpts;
vector<shared_ptr<IntersectionCurve> > intcrv;
sfcvintersect.getResult(intpts, intcrv);
cout << "Number of points: " << intpts.size() << endl;
cout << "Number of curves: " << intcrv.size() << endl;
for (int ki = 0; ki < int(intpts.size()); ki++) {
double dist = intpts[ki]->getDist();
vector<double> par = intpts[ki]->getPar();
for (int kj = 0; kj < int(par.size()); kj++)
cout << par[kj] << " ";
cout << ": dist = " << dist << endl;
}
// Write regression test data
int npoints = (int)intpts.size();
int ncurves = (int)intcrv.size();
vector<double> par;
out << "-1 ______________Case sf-cv intersector______________"
<< endl;
out << "0 Surf-Curve: npoints = " << npoints
<< " ncurves = " << ncurves << endl;
for (int i = 0; i < npoints; ++i) {
out << "1 Point: ";
par = intpts[i]->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << endl;
}
for (int i = 0; i < ncurves; ++i) {
out << "2 Curve: Start = ";
int nguide = intcrv[i]->numGuidePoints();
shared_ptr<IntersectionPoint> startpt
= intcrv[i]->getGuidePoint(0);
par = startpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << " End = ";
shared_ptr<IntersectionPoint> endpt
= intcrv[i]->getGuidePoint(nguide-1);
par = endpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << endl;
}
}
else
{
SfCvIntersector sfcvintersect(ssurfint, scurveint, aepsge);
sfcvintersect.compute();
// Get the results
vector<shared_ptr<IntersectionPoint> > intpts;
vector<shared_ptr<IntersectionCurve> > intcrv;
sfcvintersect.getResult(intpts, intcrv);
cout << "Number of points: " << intpts.size() << endl;
cout << "Number of curves: " << intcrv.size() << endl;
for (int ki = 0; ki < int(intpts.size()); ki++) {
double dist = intpts[ki]->getDist();
vector<double> par = intpts[ki]->getPar();
for (int kj = 0; kj < int(par.size()); kj++)
cout << par[kj] << " ";
cout << ": dist = " << dist << endl;
}
// Write regression test data
int npoints = (int)intpts.size();
int ncurves = (int)intcrv.size();
vector<double> par;
out << "-1 ______________Case sf-cv intersector______________"
<< endl;
out << "0 Surf-Curve: npoints = " << npoints
<< " ncurves = " << ncurves << endl;
for (int i = 0; i < npoints; ++i) {
out << "1 Point: ";
par = intpts[i]->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << endl;
}
for (int i = 0; i < ncurves; ++i) {
out << "2 Curve: Start = ";
int nguide = intcrv[i]->numGuidePoints();
shared_ptr<IntersectionPoint> startpt
= intcrv[i]->getGuidePoint(0);
par = startpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << " End = ";
shared_ptr<IntersectionPoint> endpt
= intcrv[i]->getGuidePoint(nguide-1);
par = endpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << endl;
}
}
return 0;
}
int main(int argc, char** argv)
{
const string inp_curve_filename("approj_curve.g2");
cout << "\nRunning program '" << argv[0]
<< "'\nSpline curve filename= '"
<< inp_curve_filename.c_str() << "'." << endl;
// Read spline curve file
ifstream cfile(inp_curve_filename.c_str());
if (!cfile) {
cerr << "\nFile error. Could not open file: "
<< inp_curve_filename.c_str() << endl;
return 1;
}
shared_ptr<SplineCurve> curve(new SplineCurve);
ObjectHeader header;
cfile >> header;
if (!header.classType() == SplineCurve::classType()) {
THROW("Object type is NOT SplineCurve.");
}
cfile >> (*curve);
cfile.close();
// Print some curve information
Point pnt3d(3);
curve->point(pnt3d, curve->startparam());
cout << "\nSplineCurve: Dim= " << curve->dimension()
<< "\nStart. Param= " << curve->startparam() << " Point= "
<< pnt3d << endl;
curve->point(pnt3d, curve->endparam());
cout << "End. Param= " << curve->endparam() << " Point= "
<< pnt3d << endl;
cout << "Bounding box = " << curve->boundingBox() << endl;
// Create a surface by rotating the curve around the axis an angle of 2PI.
double angle = 2.0*M_PI;
Point point_on_axis(0.0, 5.0, 200.0);
Point axis_dir(1.0, 0.0, 0.0);
SplineSurface* surf =
SweepSurfaceCreator::rotationalSweptSurface(*curve, angle,
point_on_axis, axis_dir);
cout << "\nSurface: Dim= " << surf->dimension() << endl;
cout << "Bounding box = " << surf->boundingBox() << endl;
cout << "Point on axis = " << point_on_axis << endl;
cout << "Axis direction = " << axis_dir << endl;
// Open output file
ofstream fout("rotational_swept_surface.g2");
// Write curve to file. Colour=red.
fout << "100 1 0 4 255 0 0 255" << endl;
curve->write(fout);
// Write surface to file. Default colour=blue.
surf->writeStandardHeader(fout);
surf->write(fout);
// Write axis to file. Colour=green.
double dlength = 1.2*(surf->boundingBox().high()[0] -
surf->boundingBox().low()[0]);
Point endp = point_on_axis + dlength*axis_dir;
SplineCurve* axis = new SplineCurve(point_on_axis, endp);
fout << "100 1 0 4 0 255 0 255" << endl;
axis->write(fout);
// cout << "Open the file 'rotational_swept_surface.g2' in 'goview' to look"
// << " at the results" << endl;
delete surf;
delete axis;
return 0;
}
int main(int argc, char** argv)
{
if (argc != 5) {
cout << "\nUsage: " << argv[0]
<< " Infile1 Infile2 continuity Outfile\n" << endl;
exit(-1);
}
cout << "\nRunning program " << argv[0]
<< "\nInfile1 = " << argv[1]
<< "\nInfile2 = " << argv[2]
<< "\ncontinuity = " << argv[3]
<< "\nOutfile = " << argv[4]
<< '\n' << endl;
// Read first curve file
ifstream infile(argv[1]);
if (!infile) {
cerr << "\nFile error. Could not open file: " << argv[1] << endl;
return 1;
}
SplineCurve curve, other_curve;
ObjectHeader header;
infile >> header >> curve;
if (!header.classType() == SplineCurve::classType()) {
THROW("Object type is NOT SplineCurve.");
}
infile.close();
// Read second curve file
ifstream infile2(argv[2]);
if (!infile2) {
cerr << "\nFile error. Could not open file: " << argv[2] << endl;
return 1;
}
infile2 >> header >> other_curve;
if (!header.classType() == SplineCurve::classType()) {
THROW("Object type is NOT SplineCurve.");
}
infile2.close();
cout << "Curve orders : " << curve.order() << " and " << other_curve.order()
<< endl;
// Append the start of the second curve to the end of the first curve.
double dist = 0; // The estimated maximum distorsion after 'smoothing' of
// joined curve to achieve the desired continuity.
int continuity = atoi(argv[3]); // Continuity. From -1 to order()-1.
bool repar = true; // The reparametrizatin of the second curve will also
// be scaled as a function of position of control
// points close to the transition.
curve.appendCurve(&other_curve, continuity, dist, repar);
cout << "Curve orders : " << curve.order() << " and " << other_curve.order()
<< " after appending curve." << endl;
cout << "Estimated difference between original and smooth curve: "
<< dist << endl;
// Write the the new curve to output file.
ofstream outfile(argv[4]);
outfile << header << curve;
return 0;
}
int main(int argc, char *argv[])
{
if (argc != 4) {
std::cout << "Usage: spline_sf (.g2) knot_ind_u_min knot_ind_v_min" << std::endl;
return -1;
}
std::ifstream filein(argv[1]); // Input lr spline.
int ind_u_min = atoi(argv[2]);
int ind_v_min = atoi(argv[3]);
ObjectHeader header;
header.read(filein);
SplineSurface spline_sf;
spline_sf.read(filein);
// We write to screen some info about the spline.
int dim = spline_sf.dimension();
int order_u = spline_sf.order_u();
int order_v = spline_sf.order_v();
int num_coefs_u = spline_sf.numCoefs_u();
int num_coefs_v = spline_sf.numCoefs_v();
std::cout << "Spline sf info: dim = " << dim << ", order_u = " << order_u << ", order_v = " << order_v << std::endl;
std::cout << " num_coefs_u = " << num_coefs_u << ", num_coefs_v = " << num_coefs_v << std::endl;
shared_ptr<SplineSurface> bez_sf;
double umin, umax, vmin, vmax;
if (ind_u_min == -1 && ind_v_min == -1)
{
puts("We use the global bezier refinement matrix code!");
bez_sf = SplineUtils::refineToBezier(spline_sf);
umin = bez_sf->startparam_u();
umax = bez_sf->endparam_u();
vmin = bez_sf->startparam_v();
vmax = bez_sf->endparam_v();
}
else
{
const BsplineBasis& basis_u = spline_sf.basis_u();
vector<double>::const_iterator iter = basis_u.begin() + ind_u_min;
umin = *iter;
while (*iter == umin)
++iter;
umax = *iter;
ind_u_min = iter - basis_u.begin() - 1;
const BsplineBasis& basis_v = spline_sf.basis_v();
iter = basis_v.begin() + ind_v_min;
vmin = *iter;
while (*iter == vmin)
++iter;
vmax = *iter;
ind_v_min = iter - basis_v.begin() - 1;
vector<double> bez_coefs, bez_coefs2;
Go::SplineUtils::refinedBezierCoefsCubic(spline_sf,
ind_u_min, ind_v_min,
bez_coefs);
int num_bez_coefs_u = order_u;
int num_bez_coefs_v = order_v;
vector<double> knots_u(order_u, umin);
knots_u.insert(knots_u.end(), order_u, umax);
vector<double> knots_v(order_v, vmin);
knots_v.insert(knots_v.end(), order_v, vmax);
bez_sf = shared_ptr<SplineSurface>
(new SplineSurface(num_bez_coefs_u, num_bez_coefs_v,
order_u, order_v,
knots_u.begin(), knots_v.begin(),
bez_coefs.begin(),
dim));
#if 0
refinedBezierCoefs(spline_sf,
ind_u_min, ind_v_min,
bez_coefs2);
SplineSurface bez_sf2(num_bez_coefs_u, num_bez_coefs_v,
order_u, order_v,
knots_u.begin(), knots_v.begin(),
bez_coefs2.begin(),
dim);
#endif
}
// And finally we compare the distance in a number of sample params.
const int num_samples_u = 137;
const int num_samples_v = 143;
double ustep = (umax - umin)/(num_samples_u -1);
double vstep = (vmax - vmin)/(num_samples_v -1);
Point spline_pt(dim), bez_pt(dim), bez_pt2(dim);
double max_dist = -1.0;
double max_dist2 = -1.0;
for (size_t kj = 0; kj < num_samples_v; ++kj)
{
double vpar = vmin + kj*vstep;
for (size_t ki = 0; ki < num_samples_u; ++ki)
{
double upar = umin + ki*ustep;
spline_sf.point(spline_pt, upar, vpar);
bez_sf->point(bez_pt, upar, vpar);
double dist = spline_pt.dist(bez_pt);
if (dist > max_dist)
max_dist = dist;
#if 0
bez_sf2.point(bez_pt2, upar, vpar);
double dist2 = spline_pt.dist(bez_pt2);
if (dist2 > max_dist2)
max_dist2 = dist2;
#endif
}
}
std::cout << "max_dist: " << max_dist << std::endl;
#if 0
std::cout << "max_dist2: " << max_dist2 << std::endl;
#endif
}
int main(int argc, char** argv)
{
bool surface_model = true;
char* infile = 0;
for (int i = 1; i < argc; i++)
if (!infile)
infile = argv[i];
else
std::cerr <<" ** Unknown option ignored: "<< argv[i] << std::endl;
size_t i = 0;
while (i < strlen(infile) && isspace(infile[i])) i++;
std::ifstream isp(infile+i);
// For spline surface models
std::vector<SplineSurface*> in_surf;
// For spline volume models
std::vector<SplineVolume*> in_vol;
ObjectHeader head;
int n = 0;
while (!isp.eof()) {
head.read(isp);
if (head.classType() == Class_SplineVolume) {
SplineVolume* v(new SplineVolume());
v->read(isp);
in_vol.push_back(v);
surface_model = false;
}
else if (head.classType() == Class_SplineSurface) {
SplineSurface* s(new SplineSurface());
s->read(isp);
in_surf.push_back(s);
surface_model = true;
}
else
std::cerr << "Unknown spline model" << std::endl;
// Ignore blanks
ws(isp);
}
if (surface_model) {
std::vector<SplineSurface*> out_surf;
for (i = 0;i < in_surf.size();i++) {
SplineSurface* s_it = in_surf[i];
// basis1 should be one degree higher than basis2 and C^p-1 continuous
int ndim = s_it->dimension();
Go::BsplineBasis b1 = s_it->basis(0).extendedBasis(s_it->order_u()+1);
Go::BsplineBasis b2 = s_it->basis(1).extendedBasis(s_it->order_v()+1);
// Note: Currently this is implemented for non-rational splines only.
// TODO: Ask the splines people how to fix this properly, that is, how
// may be obtain the correct weights for basis1 when *surf is a NURBS?
if (s_it->rational())
std::cerr <<"WARNING: The geometry basis is rational (using NURBS)\n."
<<" The basis for the unknown fields of one degree"
<<" higher will however be non-rational.\n"
<<" This may affect accuracy.\n"<< std::endl;
// Compute parameter values of the Greville points
size_t k;
std::vector<double> ug(b1.numCoefs()), vg(b2.numCoefs());
for (k = 0; k < ug.size(); k++)
ug[k] = b1.grevilleParameter(k);
for (k = 0; k < vg.size(); k++)
vg[k] = b2.grevilleParameter(k);
// Evaluate the spline surface at all points
std::vector<double> XYZ(ndim*ug.size()*vg.size());
s_it->gridEvaluator(XYZ,ug,vg);
// Project the coordinates onto the new basis (the 2nd XYZ is dummy here)
SplineSurface* s;
s = Go::SurfaceInterpolator::regularInterpolation(b1,b2,
ug,vg,XYZ,
ndim,false,XYZ);
out_surf.push_back(s);
s->writeStandardHeader(std::cout);
s->write(std::cout);
}
for (i = 0;i < out_surf.size();i++) {
delete in_surf[i];
delete out_surf[i];
}
}
else {
std::vector<SplineVolume*> out_vol;
for (i = 0;i < in_vol.size();i++) {
SplineVolume* v_it = in_vol[i];
// basis1 should be one degree higher than basis2 and C^p-1 continuous
int ndim = v_it->dimension();
Go::BsplineBasis b1 = v_it->basis(0).extendedBasis(v_it->order(0)+1);
Go::BsplineBasis b2 = v_it->basis(1).extendedBasis(v_it->order(1)+1);
Go::BsplineBasis b3 = v_it->basis(2).extendedBasis(v_it->order(2)+1);
// Note: Currently this is implemented for non-rational splines only.
// TODO: Ask the splines people how to fix this properly, that is, how
// may be obtain the correct weights for basis1 when *v_it is a NURBS?
if (v_it->rational())
std::cerr <<"WARNING: The geometry basis is rational (using NURBS)\n."
<<" The basis for the unknown fields of one degree"
<<" higher will however be non-rational.\n"
<<" This may affect accuracy.\n"<< std::endl;
// Compute parameter values of the Greville points
size_t k;
std::vector<double> ug(b1.numCoefs()), vg(b2.numCoefs()), wg(b3.numCoefs());
for (k = 0; i < ug.size(); k++)
ug[k] = b1.grevilleParameter(k);
for (k = 0; i < vg.size(); k++)
vg[k] = b2.grevilleParameter(k);
for (k = 0; i < wg.size(); k++)
wg[k] = b3.grevilleParameter(k);
// Evaluate the spline surface at all points
std::vector<double> XYZ(ndim*ug.size()*vg.size()*wg.size());
v_it->gridEvaluator(ug,vg,wg,XYZ);
// Project the coordinates onto the new basis (the 2nd XYZ is dummy here)
SplineVolume* v;
v = Go::VolumeInterpolator::regularInterpolation(b1,b2,b3,
ug,vg,wg,XYZ,
ndim,false,XYZ);
out_vol.push_back(v);
v->writeStandardHeader(std::cout);
v->write(std::cout);
}
for (i = 0;i < out_vol.size();i++) {
delete in_vol[i];
delete out_vol[i];
}
}
return 0;
}
int main(int argc, char *argv[])
{
if (argc != 4) {
std::cout << "Usage: lrspline_in (.g2) refinement_in lrspline_out.g2 " << std::endl;
return -1;
}
std::ifstream filein(argv[1]);
std::ifstream filein2(argv[2]);
std::ofstream fileout(argv[3]);
// Create the default factory
GoTools::init();
Registrator<LRSplineSurface> r293;
// Read input surface
ObjectHeader header;
try {
header.read(filein);
}
catch (...)
{
std::cerr << "Exiting" << std::endl;
exit(-1);
}
shared_ptr<GeomObject> geom_obj(Factory::createObject(header.classType()));
geom_obj->read(filein);
shared_ptr<ParamSurface> sf = dynamic_pointer_cast<ParamSurface, GeomObject>(geom_obj);
if (!sf.get())
{
std::cerr << "Input file contains no surface" << std::endl;
exit(-1);
}
shared_ptr<LRSplineSurface> lrsf =
dynamic_pointer_cast<LRSplineSurface, ParamSurface>(sf);
if (!lrsf.get())
{
shared_ptr<SplineSurface> splsf =
dynamic_pointer_cast<SplineSurface, ParamSurface>(sf);
if (splsf.get())
lrsf = shared_ptr<LRSplineSurface>(new LRSplineSurface(splsf.get(), 1.0e-6));
}
if (!lrsf.get())
{
std::cerr << "Input file contains no spline surface" << std::endl;
exit(-1);
}
shared_ptr<LRSplineSurface> tmp2(lrsf->clone());
if (tmp2->dimension() == 1)
tmp2->to3D();
// tmp2->writeStandardHeader(fileout);
// tmp2->write(fileout);
// fileout << std::endl;
// LineCloud lines2 = tmp2->getElementBds();
// lines2.writeStandardHeader(fileout);
// lines2.write(fileout);
int nmb_refs;
filein2 >> nmb_refs;
for (int ki=0; ki<nmb_refs; ++ki)
{
double parval, start, end;
int dir;
int mult;
filein2 >> parval;
filein2 >> start;
filein2 >> end;
filein2 >> dir;
filein2 >> mult;
//lrsf->refine((dir==0) ? XFIXED : YFIXED, parval, start, end, mult);
std::cout << "Iteration no. " << ki << std::endl;
lrsf->refine((dir==0) ? XFIXED : YFIXED, parval, start, end, mult, true);
puts("Writing lr-spline to file.");
if (lrsf->dimension() == 1)
lrsf->to3D();
lrsf->writeStandardHeader(fileout);
lrsf->write(fileout);
fileout << std::endl;
}
return 0;
}
int main(int argc, char** argv)
{
if (argc != 6)
{
cout << "Usage: " << argv[0] << " surfaceinfile surface3doutfile points3doutfile num_u num_v" << endl;
exit(-1);
}
ifstream filein(argv[1]);
ALWAYS_ERROR_IF(filein.bad(), "Bad or no curvee input filename");
ObjectHeader head;
filein >> head;
if (head.classType() != SplineSurface::classType()) {
THROW("Not a spline surface");
}
SplineSurface sf;
filein >> sf;
ofstream fileoutsurf(argv[2]);
ALWAYS_ERROR_IF(fileoutsurf.bad(), "Bad surface output filename");
ofstream fileoutpts(argv[3]);
ALWAYS_ERROR_IF(fileoutpts.bad(), "Bad points output filename");
int num_u = atoi(argv[4]);
int num_v = atoi(argv[5]);
vector<double> pts, param_u, param_v;
sf.gridEvaluator(num_u, num_v, pts, param_u, param_v);
vector<double> coefs3d;
vector<Point> pts3d;
int dim = sf.dimension();
bool rational = sf.rational();
int ctrl_pts = sf.numCoefs_u() * sf.numCoefs_v();
vector<double>::const_iterator it = sf.ctrl_begin();
for (int i = 0; i < ctrl_pts; ++i)
{
if (dim <= 3)
for (int j = 0; j < 3; ++j)
{
if (j>=dim)
coefs3d.push_back(0.0);
else
{
coefs3d.push_back(*it);
++it;
}
}
else
{
for (int j = 0; j < 3; ++j, ++it)
coefs3d.push_back(*it);
it += (dim-3);
}
if (rational)
{
coefs3d.push_back(*it);
++it;
}
}
int pts_pos = 0;
for (int i = 0; i < num_u*num_v; ++i)
{
double x, y, z;
if (dim == 0)
x = 0.0;
else
x = pts[pts_pos];
if (dim <= 1)
y = 0.0;
else
y = pts[pts_pos+1];
if (dim <= 2)
z = 0.0;
else
z = pts[pts_pos+2];
pts_pos += dim;
pts3d.push_back(Point(x, y, z));
}
SplineSurface sf3d(sf.basis_u(), sf.basis_v(), coefs3d.begin(), 3, rational);
sf3d.writeStandardHeader(fileoutsurf);
sf3d.write(fileoutsurf);
fileoutpts << "400 1 0 4 255 255 0 255" << endl;
fileoutpts << pts3d.size() << endl;
for (int i = 0; i < (int)pts3d.size(); ++i)
fileoutpts << pts3d[i] << endl;
}
int main(int argc, char** argv)
{
if (argc != 3) {
cout << "Usage: pickSingularRegion FileSf1 FileSf2"
<< endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream input1(argv[1]);
if (input1.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input1);
shared_ptr<ParamSurface> surf1(new SplineSurface());
surf1->read(input1);
input1.close();
// Read the second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
shared_ptr<ParamSurface> surf2(new SplineSurface());
surf2->read(input2);
input2.close();
cout << setprecision(15);
// Make the first subsurface
SplineSurface* sf1 = dynamic_cast<SplineSurface*>(surf1.get());
double from_upar = 52.0248;
double from_vpar = 0.968029;
double to_upar = sf1->endparam_u();
double to_vpar = 1.03197;
SplineSurface* sub1
= sf1->subSurface(from_upar, from_vpar, to_upar, to_vpar);
// Make the second subsurface
SplineSurface* sf2 = dynamic_cast<SplineSurface*>(surf2.get());
from_upar = 52.03;
from_vpar = 0.968027;
to_upar = 52.0349;
to_vpar = 1.03197;
SplineSurface* sub2
= sf2->subSurface(from_upar, from_vpar, to_upar, to_vpar);
// Magnify in the direction normal to the surfaces
typedef vector<double>::iterator iter;
for (iter it = sub1->coefs_begin(); it != sub1->coefs_end(); it += 3) {
it[0] -= 5.5;
it[1] += 10.6;
it[2] += 21.9;
it[0] *= 100;
it[1] *= 100;
it[2] *= 100;
}
for (iter it = sub2->coefs_begin(); it != sub2->coefs_end(); it += 3) {
it[0] -= 5.5;
it[1] += 10.6;
it[2] += 21.9;
it[0] *= 100;
it[1] *= 100;
it[2] *= 100;
}
Point normal1 = sub1->normalCone().centre();
Point normal2 = sub2->normalCone().centre();
Point normal = normal1 + normal2;
for (iter it = sub1->coefs_begin(); it != sub1->coefs_end(); it += 3) {
Point coef(it[0], it[1], it[2]);
double fac = normal * coef;
fac *= 100.0;
it[0] += fac * normal[0];
it[1] += fac * normal[1];
it[2] += fac * normal[2];
}
for (iter it = sub2->coefs_begin(); it != sub2->coefs_end(); it += 3) {
Point coef(it[0], it[1], it[2]);
double fac = normal * coef;
fac *= 100.0;
it[0] += fac * normal[0];
it[1] += fac * normal[1];
it[2] += fac * normal[2];
}
ofstream out1("subsurf1.g2");
sub1->writeStandardHeader(out1);
sub1->write(out1);
ofstream out2("subsurf2.g2");
sub2->writeStandardHeader(out2);
sub2->write(out2);
return 0;
}
int main(int argc, char** argv)
{
#ifndef _MSC_VER
// _putenv("DEBUG=1");
// _putenv("DEBUG_PAR=1");
// _putenv("DEBUG_FINISH=1");
// _putenv("DEBUG_IMPL=1");
setenv("DEBUG", "1", 1);
setenv("DEBUG_PAR", "1", 1);
setenv("DEBUG_FINISH", "1", 1);
//setenv("DEBUG_IMPL", "1", 1);
setenv("SUBDIV_SFSF", "1", 1);
setenv("DEBUG_MOVE", "1", 1);
//setenv("DO_REPAIR", "1", 1);
if (getenv("DEBUG") && (*getenv("DEBUG"))=='1')
cout << "DEBUG=1" << endl;
if (getenv("DEBUG_PAR") && (*getenv("DEBUG_PAR"))=='1')
cout << "DEBUG_PAR=1" << endl;
if (getenv("DEBUG_FINISH") && (*getenv("DEBUG_FINISH"))=='1')
cout << "DEBUG_FINISH=1" << endl;
if (getenv("DEBUG_IMPL") && (*getenv("DEBUG_IMPL"))=='1')
cout << "DEBUG_IMPL=1" << endl;
if (getenv("SUBDIV_SFSF") && (*getenv("SUBDIV_SFSF"))=='1')
cout << "SUBDIV_SFSF=1" << endl;
if (getenv("DEBUG_MOVE") && (*getenv("DEBUG_MOVE"))=='1')
cout << "DEBUG_MOVE=1" << endl;
if (getenv("DO_REPAIR") && (*getenv("DO_REPAIR"))=='1')
cout << "DO_REPAIR=1" << endl;
#endif // _MSC_VER
if (argc != 4 && argc != 5 && argc != 6) {
cout << "Usage: test_SfSfIntersector FileSf1 FileSf2 "
<<" aepsge (OutputFile)(selfintflag)"
<< endl;
return 0;
}
ObjectHeader header;
// Read the first curve from file
ifstream input1(argv[1]);
if (input1.bad()) {
cerr << "File #1 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input1);
shared_ptr<ParamSurface> surf1(new SplineSurface());
surf1->read(input1);
input1.close();
// Read the second curve from file
ifstream input2(argv[2]);
if (input2.bad()) {
cerr << "File #2 error (no file or corrupt file specified)."
<< std::endl;
return 1;
}
header.read(input2);
shared_ptr<ParamSurface> surf2(new SplineSurface());
surf2->read(input2);
input2.close();
double aepsge;
aepsge = atof(argv[3]);
ofstream tmpout;
if (argc >= 5)
tmpout.open(argv[4]);
ostream& out = tmpout;//(argc == 6) ? tmpout : cout;
int selfint_flag = 0;
if (argc == 6)
selfint_flag = atoi(argv[5]);
int has_sing = false;
// if (argc == 5)
// has_sing = atoi(argv[4]);
double sing[4];
// if (has_sing) {
// printf("Give singularity: ");
// scanf("%lf",sing);
// scanf("%lf",sing+1);
// sing[2] = sing[0];
// sing[3] = sing[1];
// }
// cout << setprecision(15);
// Setup the SplineSurfaceInt objects
shared_ptr<ParamGeomInt> ssurfint1 =
shared_ptr<ParamGeomInt>(new SplineSurfaceInt (surf1));
shared_ptr<ParamGeomInt> ssurfint2 =
shared_ptr<ParamGeomInt>(new SplineSurfaceInt (surf2));
// Set up and run the intersection algorithm
SfSfIntersector sfsfintersect (ssurfint1, ssurfint2, aepsge);
if (has_sing)
sfsfintersect.setHighPriSing(sing);
if (selfint_flag > 0)
sfsfintersect.setSelfintCase(selfint_flag);
clock_t start_compute = clock();
sfsfintersect.compute();
clock_t end_compute = clock();
// Get the results
vector<shared_ptr<IntersectionPoint> > intpts;
vector<shared_ptr<IntersectionCurve> > intcrv;
sfsfintersect.getResult(intpts, intcrv);
cout << "Number of points: " << intpts.size() << endl;
cout << "Number of curves: " << intcrv.size() << endl;
// Write regression test data
out << setprecision(8);
int npoints = (int)intpts.size();
int ncurves = (int)intcrv.size();
vector<double> par;
out << "-1 ______________Case sf-sf intersector______________"
<< endl;
out << "0 Surf-Surf: npoints = " << npoints
<< " ncurves = " << ncurves << endl;
for (int i = 0; i < npoints; ++i) {
out << "1 Point: ";
par = intpts[i]->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << intpts[i]->getDist() << endl;
}
for (int i = 0; i < ncurves; ++i) {
out << "2 Curve: Start = ";
int nguide = intcrv[i]->numGuidePoints();
shared_ptr<IntersectionPoint> startpt
= intcrv[i]->getGuidePoint(0);
par = startpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << startpt->getDist() << " End = ";
shared_ptr<IntersectionPoint> endpt
= intcrv[i]->getGuidePoint(nguide-1);
par = endpt->getPar();
for (int j=0; j < int(par.size()); j++) {
out << par[j] << " ";
}
out << endpt->getDist() << endl;
}
// Write out isolated intersection points
string str = "tmp_pnt.g2";
std::ofstream outf(str.c_str());
for (int ki=0; ki<int(intpts.size()); ki++) {
std::vector<IntersectionPoint*> neighbours;
intpts[ki]->getNeighbours(neighbours);
std::vector<double> par = intpts[ki]->getPar();
for (int kj=0; kj<int(par.size()); kj++)
std::cout << par[kj] << " ";
std::cout << neighbours.size() << std::endl;
Point pt1 = surf1->point(par[0], par[1]);
Point pt2 = surf2->point(par[2], par[3]);
outf << "400 1 0 4 255 0 0 255" << std::endl;
outf << "1" << std::endl;
pt1.write(outf);
outf << "\n";
outf << "400 1 0 4 0 255 0 255" << std::endl;
outf << "1" << std::endl;
pt2.write(outf);
outf << "\n";
}
cout << ">> Intersection points written to " << str << endl;
// Write out intersection curves as line-trains
str = "tmp_crv.g2";
std::ofstream outg(str.c_str());
for (int ki=0; ki<int(intcrv.size()); ki++) {
std::vector<double> guide_pt;
int nguide = intcrv[ki]->numGuidePoints();
guide_pt.reserve(3*nguide);
for (int kj=0; kj<nguide; kj++) {
shared_ptr<IntersectionPoint> currpt
= intcrv[ki]->getGuidePoint(kj);
Point pt = currpt->getPoint();
guide_pt.insert(guide_pt.end(), pt.begin(), pt.end());
if (kj>0 && kj<nguide-1)
guide_pt.insert(guide_pt.end(), pt.begin(), pt.end());
}
LineCloud line(&guide_pt[0], nguide-1);
line.writeStandardHeader(outg);
line.write(outg);
}
cout << ">> Intersection curves (line-trains) written to "
<< str << endl;
double march_tol = 100.0*aepsge;
//double march_tol = aepsge;
double ang_tol = 0.01;
// clock_t start_refine = clock();
for (int ki=0; ki<int(intcrv.size()); ki++) {
// if (ki ==2)
cout << "Entering refine..." << endl;
intcrv[ki]->refine(march_tol, ang_tol);
// intcrv[ki]->refine(march_tol, ang_tol);
// intcrv[ki]->refine(march_tol, ang_tol);
// intcrv[ki]->refine(march_tol, ang_tol);
// intcrv[ki]->refine(march_tol, ang_tol);
}
// clock_t end_refine = clock();
// Write out refined intersection curves as line-trains
str = "tmp2_crv.g2";
std::ofstream outg2(str.c_str());
for (int ki=0; ki<int(intcrv.size()); ki++) {
std::vector<double> guide_pt;
int nguide = intcrv[ki]->numGuidePoints();
guide_pt.reserve(3*nguide);
for (int kj=0; kj<nguide; kj++) {
shared_ptr<IntersectionPoint> currpt
= intcrv[ki]->getGuidePoint(kj);
Point pt = currpt->getPoint();
guide_pt.insert(guide_pt.end(), pt.begin(), pt.end());
if (kj>0 && kj<nguide-1)
guide_pt.insert(guide_pt.end(), pt.begin(), pt.end());
}
LineCloud line(&guide_pt[0], nguide-1);
line.writeStandardHeader(outg2);
line.write(outg2);
}
cout << ">> Refined intersection curves (line-trains) written to "
<< str << endl;
// Write out intersection curves as spline curve
str = "tmp3_crv.g2";
std::ofstream outg3(str.c_str());
for (int ki=0; ki<int(intcrv.size()); ki++) {
shared_ptr<ParamCurve> splcrv = intcrv[ki]->getCurve();
if (splcrv.get()) {
// splcrv->writeStandardHeader(outg3);
outg3 << "100 1 0 4 50 205 50 255" << endl;
splcrv->write(outg3);
}
}
cout << ">> Intersection curve (spline curve) written to "
<< str << endl;
// Write out intersection curves in the parameter plane of the
// first surface
str = "tmp4_crv.g2";
std::ofstream outg4(str.c_str());
for (int ki=0; ki<int(intcrv.size()); ki++) {
shared_ptr<ParamCurve> splcrv = intcrv[ki]->getParamCurve(1);
if (splcrv.get()) {
splcrv->writeStandardHeader(outg4);
splcrv->write(outg4);
}
}
cout << ">> Intersection curves (in parameter plane of 1st surface) "
<< "written to " << str << endl;
// Write out intersection curves in the parameter plane of the
// second surface
str = "tmp5_crv.g2";
std::ofstream outg5(str.c_str());
for (int ki=0; ki<int(intcrv.size()); ki++) {
shared_ptr<ParamCurve> splcrv = intcrv[ki]->getParamCurve(2);
if (splcrv.get()) {
splcrv->writeStandardHeader(outg5);
splcrv->write(outg5);
}
}
cout << ">> Intersection curves (in parameter plane of 2nd surface) "
<< "written to " << str << endl;
cout << "Time in intersector:\t"
<< (double)(end_compute - start_compute) / double(1000)
<< " msec. " << endl;
// cout << "Time spent for refining:\t"
// << (end_refine - start_refine) / double(1000)
// << " msec." << endl;
return 0;
}
