//===== Read File =====//
void bicubic_surf::read(FILE* file_id)
{
float x, y, z;
char buff[255];
fgets(buff, 80, file_id);
fscanf(file_id, "%d",&surface_number); fgets(buff, 80, file_id);
fgets(buff, 80, file_id);
fscanf(file_id, "%d",&u_render); fgets(buff, 80, file_id);
fscanf(file_id, "%d",&w_render); fgets(buff, 80, file_id);
fscanf(file_id, "%d",&num_pnts_u); fgets(buff, 80, file_id);
fscanf(file_id, "%d",&num_pnts_w); fgets(buff, 80, file_id);
this->init(num_pnts_u, num_pnts_w);
for ( int i = 0 ; i < num_pnts_u ; i++)
{
for ( int j = 0 ; j < num_pnts_w ; j++)
{
fscanf(file_id, "%f %f %f",&x, &y, &z); fgets(buff, 80, file_id);
pnts(i,j) = vec3d(x,y,z);
}
}
this->comp_tans();
}
NumLibSpatialFunctionQuad() :
_geometric_size(10.0), _number_of_subdivisions_per_direction(10),
_msh(MeshLib::MeshGenerator::generateRegularQuadMesh(_geometric_size, _number_of_subdivisions_per_direction)),
_project_name("test"), _mshNodesSearcher(*_msh), _ply0(nullptr)
{
// create geometry
std::vector<GeoLib::Point*>* pnts (new std::vector<GeoLib::Point*>);
pnts->push_back(new GeoLib::Point(0.0, 0.0, 0.0));
pnts->push_back(new GeoLib::Point(_geometric_size, 0.0, 0.0));
pnts->push_back(new GeoLib::Point(_geometric_size, _geometric_size, 0.0));
pnts->push_back(new GeoLib::Point(0.0, _geometric_size, 0.0));
std::vector<GeoLib::Polyline*>* plys (new std::vector<GeoLib::Polyline*>);
_ply0 = new GeoLib::Polyline(*pnts);
_ply0->addPoint(0);
_ply0->addPoint(1);
plys->push_back(_ply0);
GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts);
ply1->addPoint(0);
ply1->addPoint(1);
ply1->addPoint(2);
ply1->addPoint(3);
ply1->addPoint(0);
plys->push_back(ply1);
std::vector<GeoLib::Surface*>* sfcs (new std::vector<GeoLib::Surface*>);
_sfc1 = GeoLib::Surface::createSurface(*ply1);
sfcs->push_back(_sfc1);
_geo_objs.addPointVec(pnts,_project_name);
_geo_objs.addPolylineVec(plys, _project_name);
_geo_objs.addSurfaceVec(sfcs, _project_name);
}
TEST(GeoLib, SearchNearestPointsInDenseGrid)
{
const std::size_t i_max(50), j_max(50), k_max(50);
std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
// fill the vector with equi-distant points in the
// cube [0,(i_max-1)/i_max] x [0,(j_max-1)/j_max] x [0,(k_max-1)/k_max]
for (std::size_t i(0); i < i_max; i++) {
std::size_t offset0(i * j_max * k_max);
for (std::size_t j(0); j < j_max; j++) {
std::size_t offset1(j * k_max + offset0);
for (std::size_t k(0); k < k_max; k++) {
pnts[offset1 + k] = new GeoLib::Point(
std::array<double,3>({{static_cast<double>(i) / i_max,
static_cast<double>(j) / j_max,
static_cast<double>(k) / k_max}}), offset1+k);
}
}
}
// create the grid
GeoLib::Grid<GeoLib::Point>* grid(nullptr);
ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::Point> (pnts.begin(), pnts.end()));
// search point (1,1,1) is outside of the point set
GeoLib::Point search_pnt(std::array<double,3>({{1,1,1}}), 0);
GeoLib::Point* res(grid->getNearestPoint(search_pnt));
ASSERT_EQ(i_max*j_max*k_max-1, res->getID());
ASSERT_NEAR(sqrt(3.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
// search point (0,1,1) is outside of the point set
search_pnt[0] = 0;
res = grid->getNearestPoint(search_pnt);
ASSERT_EQ(j_max*k_max - 1, res->getID());
ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
// search point (0.5,1,1) is outside of the point set
search_pnt[0] = 0.5;
res = grid->getNearestPoint(search_pnt);
ASSERT_EQ(j_max*k_max*(i_max/2 + 1) - 1, res->getID());
ASSERT_NEAR(sqrt(2.0)/50.0, sqrt(MathLib::sqrDist(*res, search_pnt)), std::numeric_limits<double>::epsilon());
// checking only every fourth point per direction to reduce the run time of
// the test
for (std::size_t i(0); i < i_max; i=i+4) {
std::size_t offset0(i * j_max * k_max);
for (std::size_t j(0); j < j_max; j=j+4) {
std::size_t offset1(j * k_max + offset0);
for (std::size_t k(0); k < k_max; k=k+4) {
res = grid->getNearestPoint(*pnts[offset1+k]);
ASSERT_EQ(offset1+k, res->getID());
ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, *pnts[offset1+k])), 0.0, std::numeric_limits<double>::epsilon());
}
}
}
delete grid;
std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::Point>());
}
//===== Compute Point On Curve Given U =====//
vec3d bicubic_surf::comp_pnt(double u, double w)
{
double F1u, F2u, F3u, F4u;
double F1w, F2w, F3w, F4w;
int u_index = (int)u;
if (u_index >= num_pnts_u-1)
{
F1u = F3u = F4u = 0.0;
F2u = 1.0;
u_index--;
}
else
{
blend_funcs(u-(double)u_index, F1u, F2u, F3u, F4u);
}
int w_index = (int)w;
if (w_index >= num_pnts_w-1)
{
F1w = F3w = F4w = 0.0;
F2w = 1.0;
w_index--;
}
else
{
blend_funcs(w-(double)w_index, F1w, F2w, F3w, F4w);
}
vec3d new_pnt;
new_pnt = (( pnts(u_index,w_index)*F1u + pnts(u_index+1,w_index)*F2u +
tanu(u_index,w_index)*F3u + tanu(u_index+1,w_index)*F4u) * F1w) +
(( pnts(u_index,w_index+1)*F1u + pnts(u_index+1,w_index+1)*F2u +
tanu(u_index,w_index+1)*F3u + tanu(u_index+1,w_index+1)*F4u) * F2w) +
(( tanw(u_index,w_index)*F1u + tanw(u_index+1,w_index)*F2u) * F3w) +
(( tanw(u_index,w_index+1)*F1u + tanw(u_index+1,w_index+1)*F2u)* F4w);
return(new_pnt);
}
TEST(GeoLib, SearchNearestPointsInDenseGrid)
{
const std::size_t i_max(50), j_max(50), k_max(50);
std::vector<GeoLib::PointWithID*> pnts(i_max*j_max*k_max);
// fill the vector with equi-distant points in the
// cube [0,(i_max-1)/i_max] x [0,(j_max-1)/j_max] x [0,(k_max-1)/k_max]
for (std::size_t i(0); i < i_max; i++) {
std::size_t offset0(i * j_max * k_max);
for (std::size_t j(0); j < j_max; j++) {
std::size_t offset1(j * k_max + offset0);
for (std::size_t k(0); k < k_max; k++) {
pnts[offset1 + k] = new GeoLib::PointWithID(static_cast<double>(i) / i_max,
static_cast<double>(j) / j_max, static_cast<double>(k) / k_max, offset1+k);
}
}
}
// create the grid
GeoLib::Grid<GeoLib::PointWithID>* grid(nullptr);
ASSERT_NO_THROW(grid = new GeoLib::Grid<GeoLib::PointWithID> (pnts.begin(), pnts.end()));
// search point (1,1,1) is outside of the point set
GeoLib::PointWithID search_pnt(1,1,1, 0);
GeoLib::PointWithID* res(grid->getNearestPoint(search_pnt.getCoords()));
ASSERT_EQ(res->getID(), i_max*j_max*k_max-1);
ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, search_pnt)), sqrt(3.0)/50.0, std::numeric_limits<double>::epsilon());
// search point (0,1,1) is outside of the point set
search_pnt[0] = 0;
res = grid->getNearestPoint(search_pnt.getCoords());
ASSERT_EQ(res->getID(), j_max*k_max - 1);
ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, search_pnt)), sqrt(2.0)/50.0, std::numeric_limits<double>::epsilon());
// search point (0.5,1,1) is outside of the point set
search_pnt[0] = 0.5;
res = grid->getNearestPoint(search_pnt.getCoords());
ASSERT_EQ(res->getID(), j_max*k_max*(i_max/2 + 1) - 1);
ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, search_pnt)), sqrt(2.0)/50.0, std::numeric_limits<double>::epsilon());
for (std::size_t i(0); i < i_max; i++) {
std::size_t offset0(i * j_max * k_max);
for (std::size_t j(0); j < j_max; j++) {
std::size_t offset1(j * k_max + offset0);
for (std::size_t k(0); k < k_max; k++) {
res = grid->getNearestPoint(pnts[offset1+k]->getCoords());
ASSERT_EQ(res->getID(), offset1+k);
ASSERT_NEAR(sqrt(MathLib::sqrDist(*res, *pnts[offset1+k])), 0.0, std::numeric_limits<double>::epsilon());
}
}
}
delete grid;
std::for_each(pnts.begin(), pnts.end(), std::default_delete<GeoLib::PointWithID>());
}
void Draw_Triangle::drawImage(QPainter *painter, QString &text,QPointF point)
{
QString str_x,str_y;
QString color_r,color_g,color_b;
QPainterPath triangle;
triangle_pnts[0]=StrtPnt;
triangle_pnts[1]=EndPnt;
triangle_pnts[2]=HeightPnt;
triangle_pnts[3]=StrtPnt;
QVector<QPointF> pnts(triangle_pnts.size());
for(int i=0;i<pnts.size();i++)
{
pnts[i]=triangle_pnts[i];
pnts[i]+=point;
//qDebug()<<"triangle pnts "<<pnts[i]<<"\n";
}
//qDebug()<<"triangles "<<this->triangle_pnts.size()<<"\n";
triangle.moveTo(pnts[0].x(),pnts[0].y());
triangle.addPolygon(QPolygonF(pnts));
painter->setPen(this->pen);
painter->setBrush(this->brush);
painter->drawPath(triangle);
text+="Triangle\n";
text+="Coords";
text+=" "+str_x.setNum(this->triangle_pnts.size()*2.0);
for(int j=0;j<this->triangle_pnts.size()-1;j++)
{
text+=" "+str_x.setNum((this->triangle_pnts[j].x()))+" "+str_y.setNum((this->triangle_pnts[j].y()))+" ";
}
text+="PenColor";
text+=" "+color_r.setNum(this->pen.color().red())+" "+color_g.setNum(this->pen.color().green())+" "+color_b.setNum(this->pen.color().blue())+"\n";
text+="PenStyle";
text+=" "+color_r.setNum(this->pen.style())+"\n";
text+="PenWidth";
text+=" "+color_r.setNum(this->pen.width())+"\n";
text+="BrushColor";
text+=" "+color_r.setNum(this->brush.color().red())+" "+color_g.setNum(this->brush.color().green())+" "+color_b.setNum(this->brush.color().blue())+"\n";
text+="BrushStyle";
text+=" "+color_r.setNum(this->brush.style())+"\n";
text+="Rotation";
text+=" "+color_r.setNum(this->item->rotation(),'g',6)+"\n";
}
void Draw_Polygon::drawImage(QPainter *painter, QString &text,QPointF point)
{
QString str_x,str_y,str_x1,str_y1;
QString color_r,color_g,color_b;
QVector<QPointF> pnts(poly_pnts.size());
for(int i=0;i<pnts.size();i++)
{
pnts[i]=poly_pnts[i];
pnts[i]+=point;
}
if(!poly_pnts.isEmpty())
{
QPainterPath polygon;
polygon.addPolygon(QPolygonF(pnts));
painter->setPen(this->pen);
painter->setBrush(this->brush);
painter->drawPath(polygon);
text+="Polygon\n";
text+="Coords";
text+=" "+str_x.setNum(this->poly_pnts.size()*2);
for(int j=0;j<this->poly_pnts.size();j++)
{
text+=" "+str_x.setNum((this->poly_pnts[j].x()))+" "+str_y.setNum((this->poly_pnts[j].y()))+" ";
}
text+="PenColor";
text+=" "+color_r.setNum(this->pen.color().red())+" "+color_g.setNum(this->pen.color().green())+" "+color_b.setNum(this->pen.color().blue())+"\n";
text+="PenStyle";
text+=" "+color_r.setNum(this->pen.style())+"\n";
text+="PenWidth";
text+=" "+color_r.setNum(this->pen.width())+"\n";
text+="BrushColor";
text+=" "+color_r.setNum(this->brush.color().red())+" "+color_g.setNum(this->brush.color().green())+" "+color_b.setNum(this->brush.color().blue())+"\n";
text+="BrushStyle";
text+=" "+color_r.setNum(this->brush.style())+"\n";
text+="Rotation";
text+=" "+color_r.setNum(this->item->rotation(),'g',6)+"\n";
}
}
void tri_hp_ps::setup_preconditioner() {
int tind,i,j,side;
FLT jcb,h,hmax,lam1,gam,gami;
TinyVector<int,3> v;
/***************************************/
/** DETERMINE PSEUDO-TIME STEP ****/
/***************************************/
gbl->vprcn(Range(0,npnt-1),Range::all()) = 0.0;
if (basis::tri(log2p)->sm() > 0) {
gbl->sprcn(Range(0,nseg-1),Range::all()) = 0.0;
}
for(tind = 0; tind < ntri; ++tind) {
jcb = 0.25*area(tind); // area is 2 x triangle area
v = tri(tind).pnt;
hmax = 0.0;
for(j=0;j<3;++j) {
h = pow(pnts(v(j))(0) -pnts(v((j+1)%3))(0),2.0) +
pow(pnts(v(j))(1) -pnts(v((j+1)%3))(1),2.0);
hmax = (h > hmax ? h : hmax);
}
hmax = sqrt(hmax);
if (!(jcb > 0.0)) { // THIS CATCHES NAN'S TOO
*gbl->log << "negative triangle area caught in tstep. Problem triangle is : " << tind << std::endl;
*gbl->log << "approximate location: " << pnts(v(0))(0) << ' ' << pnts(v(0))(1) << std::endl;
tri_mesh::output("negative",grid);
sim::abort(__LINE__,__FILE__,gbl->log);
}
h = 4.*jcb/(0.25*(basis::tri(log2p)->p() +1)*(basis::tri(log2p)->p()+1)*hmax);
hmax = hmax/(0.25*(basis::tri(log2p)->p() +1)*(basis::tri(log2p)->p()+1));
gami = pow(hmax/(2.*gbl->mu),2.0) +gbl->lami*hmax*hmax/gbl->mu;
gam = 1./gami;
lam1 = sqrt(gam);
/* SET UP DISSIPATIVE COEFFICIENTS */
gbl->tau(tind) = adis*h/(jcb*lam1);
jcb *= (8.*gbl->mu*(1./(hmax*hmax) +1./(h*h))) ;
gbl->tprcn(tind,0) = jcb;
gbl->tprcn(tind,1) = jcb;
gbl->tprcn(tind,2) = jcb/gam;
for(i=0;i<3;++i) {
gbl->vprcn(v(i),Range::all()) += gbl->tprcn(tind,Range::all());
if (basis::tri(log2p)->sm() > 0) {
side = tri(tind).seg(i);
gbl->sprcn(side,Range::all()) += gbl->tprcn(tind,Range::all());
}
}
}
tri_hp::setup_preconditioner();
return;
}
void RadiusEdgeRatioMetric::calculateQuality ()
{
std::vector<MeshLib::Element*> const& elements(_mesh.getElements());
std::size_t const nElements (_mesh.getNumberOfElements());
for (std::size_t k(0); k < nElements; k++)
{
Element const& elem (*elements[k]);
std::size_t const n_nodes (elem.getNumberOfBaseNodes());
std::vector<MathLib::Point3d*> pnts(n_nodes);
std::copy_n(elem.getNodes(), n_nodes, pnts.begin());
GeoLib::MinimalBoundingSphere const s(pnts);
double min, max;
elem.computeSqrEdgeLengthRange(min, max);
_element_quality_metric[k] = sqrt(min)/(2*s.getRadius());
}
}
TEST(GeoLib, GEOObjectsMergePointsAndPolylines)
{
GeoLib::GEOObjects geo_objs;
std::vector<std::string> names;
// *** insert points to vector
std::vector<GeoLib::Point*> *pnts(new std::vector<GeoLib::Point*>);
pnts->reserve(4);
pnts->push_back(new GeoLib::Point(0.0,0.0,0.0));
pnts->push_back(new GeoLib::Point(1.0,0.0,0.0));
pnts->push_back(new GeoLib::Point(1.0,1.0,0.0));
pnts->push_back(new GeoLib::Point(0.0,1.0,0.0));
std::string geometry_0("GeometryWithPntsAndPolyline");
geo_objs.addPointVec(pnts, geometry_0, nullptr, std::numeric_limits<double>::epsilon());
// *** insert polyline
GeoLib::Polyline* ply(new GeoLib::Polyline(*geo_objs.getPointVec(geometry_0)));
ply->addPoint(0);
ply->addPoint(1);
ply->addPoint(2);
ply->addPoint(3);
ply->addPoint(0);
std::vector<GeoLib::Polyline*> *plys(new std::vector<GeoLib::Polyline*>);
plys->push_back(ply);
geo_objs.addPolylineVec(plys, geometry_0, nullptr);
names.push_back(geometry_0);
// *** insert set of points number
GeoLib::Point shift (0.0,0.0,0.0);
names.push_back("PointSet0");
createSetOfTestPointsAndAssociatedNames(geo_objs, names[1], shift);
// *** merge geometries
std::string merged_geometries_name("MergedQuadGeoAndPointSet");
geo_objs.mergeGeometries(names, merged_geometries_name);
std::vector<GeoLib::Polyline*> const* const polylines =
geo_objs.getPolylineVec(merged_geometries_name);
ASSERT_TRUE(polylines != nullptr);
ASSERT_EQ(polylines->size(), 1u);
}
TEST(GeoLib, InsertManyPointsInGrid)
{
const std::size_t i_max(100), j_max(100), k_max(100);
std::vector<GeoLib::Point*> pnts(i_max*j_max*k_max);
// fill the vector with points
for (std::size_t i(0); i < i_max; i++) {
std::size_t offset0(i * j_max * k_max);
for (std::size_t j(0); j < j_max; j++) {
std::size_t offset1(j * k_max + offset0);
for (std::size_t k(0); k < k_max; k++) {
pnts[offset1 + k] = new GeoLib::Point(static_cast<double>(i) / i_max,
static_cast<double>(j) / j_max, static_cast<double>(k) / k_max);
}
}
}
ASSERT_NO_THROW(GeoLib::Grid<GeoLib::Point> grid(pnts.begin(), pnts.end()));
}
QVector<Point> Geom::Box::getConnerPoints()
{
QVector<Point> pnts(8);
QVector<Vector3> edges;
for (int i = 0; i < 3; i++)
edges.push_back( 2 * Extent[i] * Axis[i]);
pnts[0] = Center - 0.5*edges[0] - 0.5*edges[1] + 0.5*edges[2];
pnts[1] = pnts[0] + edges[0];
pnts[2] = pnts[1] - edges[2];
pnts[3] = pnts[2] - edges[0];
pnts[4] = pnts[0] + edges[1];
pnts[5] = pnts[1] + edges[1];
pnts[6] = pnts[2] + edges[1];
pnts[7] = pnts[3] + edges[1];
return pnts;
}
NumLibDistributionHex() :
_geometric_size(10.0), _number_of_subdivisions_per_direction(10),
_msh(MeshLib::MeshGenerator::generateRegularHexMesh(_geometric_size, _number_of_subdivisions_per_direction)),
_project_name("test"),
_mshNodesSearcher(*_msh,MeshGeoToolsLib::SearchLength()),
_ply0(nullptr)
{
// create geometry
std::vector<GeoLib::Point*>* pnts (new std::vector<GeoLib::Point*>);
pnts->push_back(new GeoLib::Point(0.0, 0.0, 0.0));
pnts->push_back(new GeoLib::Point(_geometric_size, 0.0, 0.0));
pnts->push_back(new GeoLib::Point(_geometric_size, _geometric_size, 0.0));
pnts->push_back(new GeoLib::Point(0.0, _geometric_size, 0.0));
pnts->push_back(new GeoLib::Point(0.0, 0.0, _geometric_size));
pnts->push_back(new GeoLib::Point(_geometric_size, 0.0, _geometric_size));
pnts->push_back(new GeoLib::Point(_geometric_size, _geometric_size, _geometric_size));
pnts->push_back(new GeoLib::Point(0.0, _geometric_size, _geometric_size));
std::vector<GeoLib::Polyline*>* plys (new std::vector<GeoLib::Polyline*>);
_ply0 = new GeoLib::Polyline(*pnts); // vertical polyline
_ply0->addPoint(0);
_ply0->addPoint(4);
plys->push_back(_ply0);
GeoLib::Polyline* ply1 = new GeoLib::Polyline(*pnts); // polygon for left surface
ply1->addPoint(0);
ply1->addPoint(3);
ply1->addPoint(7);
ply1->addPoint(4);
ply1->addPoint(0);
plys->push_back(ply1);
std::vector<GeoLib::Surface*>* sfcs (new std::vector<GeoLib::Surface*>);
_sfc1 = GeoLib::Surface::createSurface(*ply1);
sfcs->push_back(_sfc1);
_geo_objs.addPointVec(pnts,_project_name);
_geo_objs.addPolylineVec(plys, _project_name);
_geo_objs.addSurfaceVec(sfcs, _project_name);
}
void createSetOfTestPointsAndAssociatedNames(GeoLib::GEOObjects & geo_objs, std::string &name, GeoLib::Point const& shift)
{
std::vector<GeoLib::Point*> *pnts(new std::vector<GeoLib::Point*>);
std::map<std::string, std::size_t>* pnt_name_map(new std::map< std::string, std::size_t>);
const std::size_t pnts_per_edge(8);
for (std::size_t k(0); k < pnts_per_edge; k++) {
const std::size_t k_offset(k * pnts_per_edge * pnts_per_edge);
for (std::size_t j(0); j < pnts_per_edge; j++) {
const std::size_t offset(j * pnts_per_edge + k_offset);
for (std::size_t i(0); i < pnts_per_edge; i++) {
pnts->push_back(new GeoLib::Point(i+shift[0], j+shift[1], k+shift[2]));
std::string pnt_name(
name + "-" + BaseLib::number2str(i) + "-" + BaseLib::number2str(j) + "-"
+ BaseLib::number2str(k));
pnt_name_map->insert(std::pair< std::string, std::size_t>(pnt_name, i + offset));
}
}
}
geo_objs.addPointVec(pnts, name, pnt_name_map);
}
/*
return a unit vector that bisects the angle formed by three points: a-o-b.
*/
CParticleF
bisector(CParticleF& o, CParticleF& a, CParticleF& b)
{
CParticleF x = NormalizedDirection(a, o);
CParticleF y = NormalizedDirection(b, o);
CParticleF z((x.m_X + y.m_X) / 2, (x.m_Y + y.m_Y) / 2);
float vx = z.m_X;
float vy = z.m_Y;
float len0 = sqrt(vx*vx + vy*vy);
if (len0 <= 1.0e-5) //this is a colinear point.
{
float ang = GetVisualDirection(b.m_X, b.m_Y, a.m_X, a.m_Y) - PI / 2.0;
vx = cos(ang);
vy = sin(ang);
}
else
{
vx = vx / len0;
vy = vy / len0;
}
CParticleF bs(o.m_X + vx, o.m_Y + vy);
//There are two bisector directions.
//We consistently choose one that is in clock-wise direction.
vector<CParticleF> pnts(4);
pnts[0] = o;
pnts[1] = a;
pnts[2] = bs;
pnts[3] = b;
if (ClockWise(pnts)<0)
{
vx = -vx;
vy = -vy;
}
return CParticleF(vx, vy);
}
void tri_mesh::refineby2(const class tri_mesh& inmesh) {
int i,j,n,sind,tind,p0,p1,count,pnear,err,initialsidenumber;
bool found;
TinyVector<FLT,ND> xpt;
/* INPUT MESH MUST HAVE GROWTH FACTOR OF 4 */
/* BECAUSE OF gbl->intwk USAGE */
if (!initialized) {
/* VERTEX STORAGE ALLOCATION */
init(inmesh,duplicate,0.5);
}
this->copy(inmesh);
/* CALCULATE LOCATION OF NEW INTERIOR POINTS */
count = npnt;
for(sind=0;sind<nseg;++sind) {
if (seg(sind).tri(1) < 0) continue;
p0 = seg(sind).pnt(0);
p1 = seg(sind).pnt(1);
/* MIDPOINT */
for(n=0;n<ND;++n)
xpt(n) = 0.5*(pnts(p0)(n) +pnts(p1)(n));
/* INSERT POINT */
for(n=0;n<ND;++n)
pnts(count)(n) = xpt(n);
++count;
}
/* INSERT INTERIOR POINTS */
for(i=npnt;i<count;++i) {
qtree.addpt(npnt);
qtree.nearpt(npnt,pnear);
found = findtri(pnts(npnt),pnear,tind);
assert(found);
err = insert(npnt,tind);
++npnt;
}
/* INSERT BOUNDARY POINTS */
for(i=0;i<nebd;++i) {
initialsidenumber = ebdry(i)->nseg;
for(j=0;j<initialsidenumber;++j) {
sind = ebdry(i)->seg(j);
pnts(npnt) = 0.5*(pnts(seg(sind).pnt(0)) +pnts(seg(sind).pnt(1)));
ebdry(i)->mvpttobdry(j,0.0,pnts(npnt));
bdry_insert(npnt,sind);
++npnt;
}
}
for (i=0;i<nebd;++i)
ebdry(i)->reorder();
cnt_nbor();
return;
}
REALNUM_TYPE dataset::sfexcl_split(set &seed, UNSIGNED_2B_TYPE Mode, REALNUM_TYPE f, bool ifForceDistCalc, UNSIGNED_1B_TYPE toTest, UNSIGNED_1B_TYPE toTrain, UNSIGNED_1B_TYPE nSeed, REALNUM_TYPE Kmetric)
//sphere exclusion implementation with some extra features added to the basic published version
//ref: Golbraikhm A, Tropsha A et al, J Comp-Aid Mol Design 2003, 17: 241-253
//There are two ways of calculating sphere's radius R:
//1) R = f*(V/N)^1/k, where f is interpreted as Dissimilarity [0.2 .. 5.2];
//2) R = mind.dist + f(max.dist- min.dist), where f should be varied [0 .. 0.25]
//
//Parameters:
//Mode see the header-file
//seed is the set of user-supplied points for seeding, nSeed - number of points to be seeded randomly in addition to that
//toTest, toTrain #points from the sphere that are placed, respectively, into test and training set,
// which is done alternatingly (toTrain #points to training set, then toTest #points to test set, and repeated)
{
UNSIGNED_4B_TYPE C, N = patt.RowNO(), D = patt.ColNO();
SIGNED_4B_TYPE Z, Z1, el, el1;
REALNUM_TYPE R, mnD, rtD;
if ((N < 2) || (D < 2)) return 0;
if ( (N != dist.ColNO()) || (!dist.IsSquare()) || ifForceDistCalc )
{//!may be affected by changed metric-function
if (Mode & SFEXCL_METRIC_COSINE)
calc_dist(0, Kmetric, 1); //cosine-metric
else
if (Mode & SFEXCL_METRIC_CORR)
calc_dist(0, Kmetric, 2); //similar to cosine-metric, but mean-centered
else
if (Mode & SFEXCL_METRIC_TANIMOTO)
calc_dist(0, Kmetric, 3); //Tanimoto, though strange to apply it to non-discrete data : )
else
calc_dist(0, Kmetric, 0); //Euclidean-like
}
//----------------------
//prepare seeding set
if (nSeed)
{
if ((Mode & SFEXCL_SEED_BYACTS) == SFEXCL_SEED_BYACTS)
rand_split((UNSIGNED_4B_TYPE)nSeed, nSeed);
else
rand_split((UNSIGNED_4B_TYPE)nSeed, 1);
seed |= test;
}
if ((Mode & SFEXCL_SEED_MINACT) == SFEXCL_SEED_MINACT)
{
C = 0;
while (++C < N) if (act[sact[C]] > act[sact[0]]) break;
Z = GetRandomNumber(C);
seed.PutInSet(sact[Z]);
}
if ((Mode & SFEXCL_SEED_MAXACT) == SFEXCL_SEED_MAXACT)
{
C = 1;
while (++C < N) if (act[sact[N-C]] < act[sact[N-1]]) break;
Z = GetRandomNumber(--C) + 1;
seed.PutInSet(sact[N - Z]);
}
if ((Mode & SFEXCL_R_BYDIST) == SFEXCL_R_BYDIST)
R = f * (distAv - distMin) + distMin; //distMax is too big to use effectively!
else
{
if ((Mode & SFEXCL_R_BYUSER) == SFEXCL_R_BYUSER)
R = f;
else
{//default
REALNUM_TYPE l, h, V = 1;
for (C = 0; C < D; C++)
{//calculate volume of the descriptors' space
patt.GetColScale(C, C, l, h);
V *= pow(h - l, 1.0/D);
}
V /= pow(N, 1.0/D);
R = f * V;
}
}
if (R < distMin) R = distMin;
//----------------------
//prepare R-neiborhood-subsets to speed up splitting
lneib Rneibs(N);
for (C = 0; C < N - 1; C++)
for (Z = C + 1; Z < SIGNED_4B_TYPE(N); Z++)
if (dist(C, Z) < R)
{
Rneibs[C].PutInSet(Z);
Rneibs[Z].PutInSet(C);
}
//----------------------
test.Dump();
train = seed;
C = train.Size();
SIGNED_4B_TYPE nspnts = 0;
apvector<SIGNED_4B_TYPE> pnts_i(N), pnts(N - C), spnts(N), vecRneibs;
for (Z1 = Z = 0; Z < SIGNED_4B_TYPE(N); Z++)
{
if (seed.IsInSet(Z)) continue;
pnts[Z1++] = Z;
}
pnts.rand_shuffle(); //randomize datapoint positions
for (Z = 0; Z < SIGNED_4B_TYPE(N - C); Z++) pnts_i[pnts[Z]] = Z; //store randomized positions
while (C < N)
{//go on as long as there are points to exhaust
if (seed.IsEmpty())
{
if ( ((Mode & SFEXCL_NEXTSF_RAND) == SFEXCL_NEXTSF_RAND) || (nspnts == 0) )
//get random seeding point from the rest of the data
Z = 0; //GetRandomNumber( N - C ); //array has been randomized already anyway
else
{//el would store -> pnts[]
mnD = 0;
if ((Mode & SFEXCL_NEXTSF_STEP2_MIN) == SFEXCL_NEXTSF_STEP2_MIN) mnD = distMax * N;
if ((Mode & SFEXCL_NEXTSF_SPHERES) == SFEXCL_NEXTSF_SPHERES)
for (el = Z = 0; Z + C < N; Z++)
{
rtD = 0;
if ( ((Mode & SFEXCL_NEXTSF_STEP1_SUMDIST) != SFEXCL_NEXTSF_STEP1_SUMDIST) &&
((Mode & SFEXCL_NEXTSF_STEP1_MIN) == SFEXCL_NEXTSF_STEP1_MIN) )
rtD = distMax * N;
for (Z1 = 0; Z1 < nspnts; Z1++)
{
if ((Mode & SFEXCL_NEXTSF_STEP1_SUMDIST) == SFEXCL_NEXTSF_STEP1_SUMDIST)
rtD += dist(pnts[Z], spnts[Z1]);
else
if ( ((Mode & SFEXCL_NEXTSF_STEP1_MIN) == SFEXCL_NEXTSF_STEP1_MIN) ^ (dist(pnts[Z], spnts[Z1]) > rtD) )
rtD = dist(pnts[Z], spnts[Z1]);
}
if ( ((Mode & SFEXCL_NEXTSF_STEP2_MIN) == SFEXCL_NEXTSF_STEP2_MIN) ^ ( mnD < rtD ) )
{
mnD = rtD;
el = Z;
}
}
else //if ((Mode & SFEXCL_NEXTSF_SPHERES) == SFEXCL_NEXTSF_SPHERES)
for (Z = 0; Z < nspnts; Z++)
{
el1 = 0;
for (Z1 = 1; Z1 + C < N; Z1++)
if ( ((Mode & SFEXCL_NEXTSF_STEP1_MIN) == SFEXCL_NEXTSF_STEP1_MIN) ^
(dist(spnts[Z], pnts[Z1]) > dist(spnts[Z], pnts[el1])) )
el1 = Z1;
if ( ((Mode & SFEXCL_NEXTSF_STEP2_MIN) == SFEXCL_NEXTSF_STEP2_MIN) ^ ( mnD < dist(spnts[Z], pnts[el1]) ) )
{
mnD = dist(spnts[Z], pnts[el1]);
el = el1;
}
}
Z = el;
}//if ((Mode & SFEXCL_NEXTSF_RAND) == SFEXCL_NEXTSF_RAND) .. else
el = pnts[Z];
train.PutInSet(el);
C++;
pnts[Z] = pnts[N - C];
pnts_i[el] = N;
pnts_i[pnts[Z]] = Z;
}//if (seed.IsEmpty())
else
{
seed.GetElement(el);
seed.RemoveFromSet(el);
}
spnts[nspnts++] = el;
//now let's get the points within R-distance from el and distribute them between train and test
Rneibs[el].GetList(vecRneibs);
vecRneibs.rand_shuffle(); //to randomize the order of points!
for (Z1 = el1 = 0; el1 < vecRneibs.length(); el1++)
{
Z = vecRneibs[el1];
if (test.IsInSet(Z) || train.IsInSet(Z)) continue;
C++;
pnts[pnts_i[Z]] = pnts[N - C];
pnts_i[pnts[N - C]] = pnts_i[Z];
pnts_i[Z] = N;
if ((Mode & SFEXCL_SPLIT_FIRST2TRN) == SFEXCL_SPLIT_FIRST2TRN)
{
if (Z1++ < toTrain) train.PutInSet(Z); else test.PutInSet(Z);
}
else
if (Z1++ < toTest) test.PutInSet(Z); else train.PutInSet(Z);
if (Z1 == toTrain + toTest) Z1 = 0;
}
}//global-loop while (C < N)
return (R);
}
void tri_hp_ps::length() {
int i,j,k,v0,v1,v2,indx,sind,tind,count;
TinyVector<FLT,2> dx0,dx1,dx2,ep,dedpsi;
FLT q,p,duv,um,vm,u,v;
FLT sum,ruv,ratio;
FLT length0,length1,length2,lengthept;
FLT ang1,curved1,ang2,curved2;
FLT norm;
gbl->eanda = 0.0;
for(tind=0;tind<ntri;++tind) {
q = 0.0;
p = 0.0;
duv = 0.0;
um = ug.v(tri(tind).pnt(2),0);
vm = ug.v(tri(tind).pnt(2),1);
for(j=0;j<3;++j) {
v0 = tri(tind).pnt(j);
p += fabs(ug.v(v0,2));
duv += fabs(u-um)+fabs(v-vm);
}
gbl->eanda(0) += 1./3.*(p*area(tind) +duv*gbl->mu*sqrt(area(tind)) );
gbl->eanda(1) += area(tind);
}
sim::blks.allreduce(gbl->eanda.data(),gbl->eanda_recv.data(),2,blocks::flt_msg,blocks::sum);
norm = gbl->eanda_recv(0)/gbl->eanda_recv(1);
gbl->fltwk(Range(0,npnt-1)) = 0.0;
switch(basis::tri(log2p)->p()) {
case(1): {
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ruv = gbl->mu/distance(v0,v1);
sum = distance2(v0,v1)*(ruv*(fabs(ug.v(v0,0) -ug.v(v1,0)) +fabs(ug.v(v0,1) -ug.v(v1,1))) +fabs(ug.v(v0,2) -ug.v(v1,2)));
gbl->fltwk(v0) += sum;
gbl->fltwk(v1) += sum;
}
break;
}
default: {
indx = basis::tri(log2p)->sm()-1;
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ruv = +gbl->mu/distance(v0,v1);
sum = distance2(v0,v1)*(ruv*(fabs(ug.s(i,indx,0)) +fabs(ug.s(i,indx,1))) +fabs(ug.s(i,indx,2)));
gbl->fltwk(v0) += sum;
gbl->fltwk(v1) += sum;
}
/* BOUNDARY CURVATURE */
for(i=0;i<nebd;++i) {
if (!(hp_ebdry(i)->is_curved())) continue;
for(j=0;j<ebdry(i)->nseg;++j) {
sind = ebdry(i)->seg(j);
v1 = seg(sind).pnt(0);
v2 = seg(sind).pnt(1);
crdtocht1d(sind);
/* FIND ANGLE BETWEEN LINEAR SIDES */
tind = seg(sind).tri(0);
for(k=0;k<3;++k)
if (tri(tind).seg(k) == sind) break;
v0 = tri(tind).pnt(k);
dx0(0) = pnts(v2)(0)-pnts(v1)(0);
dx0(1) = pnts(v2)(1)-pnts(v1)(1);
length0 = dx0(0)*dx0(0) +dx0(1)*dx0(1);
dx1(0) = pnts(v0)(0)-pnts(v2)(0);
dx1(1) = pnts(v0)(1)-pnts(v2)(1);
length1 = dx1(0)*dx1(0) +dx1(1)*dx1(1);
dx2(0) = pnts(v1)(0)-pnts(v0)(0);
dx2(1) = pnts(v1)(1)-pnts(v0)(1);
length2 = dx2(0)*dx2(0) +dx2(1)*dx2(1);
basis::tri(log2p)->ptprobe1d(2,&ep(0),&dedpsi(0),-1.0,&cht(0,0),MXTM);
lengthept = dedpsi(0)*dedpsi(0) +dedpsi(1)*dedpsi(1);
ang1 = acos(-(dx0(0)*dx2(0) +dx0(1)*dx2(1))/sqrt(length0*length2));
curved1 = acos((dx0(0)*dedpsi(0) +dx0(1)*dedpsi(1))/sqrt(length0*lengthept));
basis::tri(log2p)->ptprobe1d(2,&ep(0),&dedpsi(0),1.0,&cht(0,0),MXTM);
lengthept = dedpsi(0)*dedpsi(0) +dedpsi(1)*dedpsi(1);
ang2 = acos(-(dx0(0)*dx1(0) +dx0(1)*dx1(1))/sqrt(length0*length1));
curved2 = acos((dx0(0)*dedpsi(0) +dx0(1)*dedpsi(1))/sqrt(length0*lengthept));
sum = gbl->curvature_sensitivity*(curved1/ang1 +curved2/ang2);
gbl->fltwk(v0) += sum*gbl->error_target*norm*pnt(v0).nnbor;
gbl->fltwk(v1) += sum*gbl->error_target*norm*pnt(v1).nnbor;
}
}
break;
}
}
for(i=0;i<npnt;++i) {
gbl->fltwk(i) = pow(gbl->fltwk(i)/(norm*pnt(i).nnbor*gbl->error_target),1./(basis::tri(log2p)->p()+1+ND));
lngth(i) /= gbl->fltwk(i);
}
/* AVOID HIGH ASPECT RATIOS */
int nsweep = 0;
do {
count = 0;
for(i=0;i<nseg;++i) {
v0 = seg(i).pnt(0);
v1 = seg(i).pnt(1);
ratio = lngth(v1)/lngth(v0);
if (ratio > 3.0) {
lngth(v1) = 2.5*lngth(v0);
++count;
}
else if (ratio < 0.333) {
lngth(v0) = 2.5*lngth(v1);
++count;
}
}
++nsweep;
*gbl->log << "#aspect ratio fixes " << nsweep << ' ' << count << std::endl;
} while(count > 0 && nsweep < 5);
return;
}
void Gmsh2GeoIO::loadMeshAsGeometry (std::string & fname, GeoLib::GEOObjects* geo)
{
// open file
std::ifstream ins (fname.c_str());
if (!ins)
{
std::cout << "could not open file " << fname << std::endl;
return;
}
std::string line;
// read gmsh header
getline (ins, line); // $MeshFormat
getline (ins, line);
getline (ins, line); // $EndMeshFormat
// read nodes tag
getline (ins, line);
// read number of nodes
getline (ins, line);
const size_t n_pnts (str2number<size_t>(line));
std::vector<GeoLib::Point*>* pnts (new std::vector<GeoLib::Point*>);
for (size_t k(0); k < n_pnts; k++)
{
getline (ins, line);
// parse id
size_t pos_beg(0);
size_t pos_end (line.find(" "));
// the sub string line.substr(pos_beg, pos_end-pos_beg) represents the id
// parse x coordinate
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
double x (str2number<double>(line.substr(pos_beg, pos_end - pos_beg)));
// parse y coordinate
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
double y (str2number<double>(line.substr(pos_beg, pos_end - pos_beg)));
// parse z coordinate
pos_beg = pos_end + 1;
pos_end = line.find("\n", pos_beg);
double z (str2number<double>(line.substr(pos_beg, pos_end - pos_beg)));
pnts->push_back (new GeoLib::Point (x,y,z));
}
// read end nodes tag
getline (ins, line);
geo->addPointVec (pnts, fname);
std::vector<size_t> const& pnt_id_map (geo->getPointVecObj(fname)->getIDMap());
// read element tag
getline (ins, line);
// read number of elements
getline (ins, line);
const size_t n_elements (str2number<size_t>(line));
GeoLib::Surface* sfc (new GeoLib::Surface (*pnts));
for (size_t k(0); k < n_elements; k++)
{
getline (ins, line);
// parse id
size_t pos_beg(0);
size_t pos_end (line.find(" "));
// the sub string line.substr(pos_beg, pos_end-pos_beg) represents the id
// parse element type
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
size_t ele_type (str2number<size_t>(line.substr(pos_beg, pos_end - pos_beg)));
if (ele_type == 2) // read 3 node triangle
{ // parse number of tags
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
const size_t n_tags (str2number<size_t>(line.substr(pos_beg,
pos_end - pos_beg)));
// (over) read tags
for (size_t j(0); j < n_tags; j++)
{
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
}
// parse first id of triangle
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
const size_t id0 (str2number<size_t>(line.substr(pos_beg,
pos_end - pos_beg)) - 1); // shift -1!
// parse second id of triangle
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
const size_t id1 (str2number<size_t>(line.substr(pos_beg,
pos_end - pos_beg)) - 1); // shift -1!
// parse third id of triangle
pos_beg = pos_end + 1;
pos_end = line.find(" ", pos_beg);
const size_t id2 (str2number<size_t>(line.substr(pos_beg,
pos_end - pos_beg)) - 1); // shift -1!
sfc->addTriangle (pnt_id_map[id0], pnt_id_map[id1], pnt_id_map[id2]);
}
}
// read end element tag
getline (ins, line);
std::vector<GeoLib::Surface*>* sfcs (new std::vector<GeoLib::Surface*>);
sfcs->push_back(sfc);
geo->addSurfaceVec (sfcs, fname);
}
void compute_splines()
{
// get point tangents first
std::cout << "HermiteSpline2D: compute_splines(): Getting tangents of boundary points." << std::endl;
for(int ipoin = 0; ipoin < m->gnbpoin(); ipoin++)
{
// in 2D, bpoints is not an array of stl std::vectors - we know there are only two faces surrounding each boundary point
// if edge is bounded by (x1,y1) and (x2,y2), tangent to edge is (x2-x1)i + (y2-y1)j
// first check if this point belongs to a face that needs to be reconstructed
if(toRec(m->gbpoints(ipoin,1))==1 || toRec(m->gbpoints(ipoin,2))==1)
{
std::vector<int> en(2);
// get intfac faces containing this point
en[0] = m->gbpoints(ipoin,1);
en[1] = m->gbpoints(ipoin,2);
//std::cout << en[0] << " " << en[1] << std::endl;
double xt, yt, dotx = 1, doty = 1, mag;
// iterate over the two faces containing ipoin
for(int i = 0; i < 2; i++)
{
xt = m->gcoords(m->gintfac(en[i],3),0) - m->gcoords(m->gintfac(en[i],2),0);
yt = m->gcoords(m->gintfac(en[i],3),1) - m->gcoords(m->gintfac(en[i],2),1);
mag = sqrt(xt*xt + yt*yt);
ptangents(m->gbpoints(ipoin,0),0) += xt;
ptangents(m->gbpoints(ipoin,0),1) += yt;
dotx *= xt/mag;
doty *= yt/mag;
}
ptangents(m->gbpoints(ipoin,0),0) /= 2.0;
ptangents(m->gbpoints(ipoin,0),1) /= 2.0;
// now normalize the averaged tangent std::vector
mag = sqrt(ptangents(m->gbpoints(ipoin,0),0)*ptangents(m->gbpoints(ipoin,0),0) + ptangents(m->gbpoints(ipoin,0),1)*ptangents(m->gbpoints(ipoin,0),1));
ptangents(m->gbpoints(ipoin,0),0) /= mag;
ptangents(m->gbpoints(ipoin,0),1) /= mag;
// check if this is a corner point
double dotp = dotx+doty; // dot product of tangents of the two faces
if(dotp < cos(angle_threshold)) {
isCorner(m->gbpoints(ipoin,0)) = 1; // set isCorner for global point number corresponding to boundary point ipoin
std::cout << "Boundary point " << m->gbpoints(ipoin,0) << " is a corner point!" << std::endl;
}
}
}
// iterate over boundary faces of the mesh
std::cout << "HermiteSpline2D: compute_splines(): Iterating over boundary faces to get tangents." << std::endl;
std::vector<int> pnts(m->gnnofa()); // to store point numbers of points making up iface
for(int iface = 0; iface < m->gnbface(); iface++)
{
if(toRec(iface) == 1)
{
// get tangent for this face
for(int inofa = 0; inofa < m->gnnofa(); inofa++)
pnts[inofa] = m->gintfac(iface,inofa+2);
// magnitude of tangent (x2-x1)i + (y2-y1)j
double mag = sqrt((m->gcoords(pnts[1],0)-m->gcoords(pnts[0],0))*(m->gcoords(pnts[1],0)-m->gcoords(pnts[0],0)) + (m->gcoords(pnts[1],1)-m->gcoords(pnts[0],1))*(m->gcoords(pnts[1],1)-m->gcoords(pnts[0],1)));
for(int inofa = 0; inofa < m->gnnofa(); inofa++)
{
if(isCorner(pnts[inofa]) == 0) // if not a corner
{
gallfa(iface,2*inofa) = ptangents(pnts[inofa],0);
gallfa(iface,2*inofa+1) = ptangents(pnts[inofa],1);
}
else // if pnts[inofa] is a corner, use this face's tangent at that point
{
gallfa(iface,2*inofa) = (m->gcoords(pnts[1],0) - m->gcoords(pnts[0],0))/mag;
gallfa(iface,2*inofa+1) = (m->gcoords(pnts[1],1) - m->gcoords(pnts[0],1))/mag;
}
}
/* Note that gallfa(*,0) contains x-component of tangent at point 1, gallfa(*,1) contains y-component of tangent at point 1,
gallfa(*,2) contains x-component of tangent at point 2, and gallfa(*,3) contains y-component of tangent at points 2. */
}
}
// iterate over boundary faces of mesh again to calculate geometric spline coeffs from gallfa and intfac
std::cout << "HermiteSpline2d: compute_splines(): Iterating over boundary faces again to compute geometric coefficients of the splines" << std::endl;
for(int iface = 0; iface < m->gnbface(); iface++)
if(toRec(iface) == 1)
{
for(int idim = 0; idim < m->gndim(); idim++)
{
cf[idim](iface,0) = m->gcoords(m->gintfac(iface,2),idim);
cf[idim](iface,1) = m->gcoords(m->gintfac(iface,3),idim);
cf[idim](iface,2) = gallfa(iface,idim);
cf[idim](iface,3) = gallfa(iface,idim+2);
}
}
}
void tet_hp::tobasis(init_bdry_cndtn *ibc, int tlvl) {
int tind,i,j,k,m,n,v0,v1,eind,find;
TinyVector<FLT,3> pt;
int stridey = MXGP;
int stridex = MXGP*MXGP;
/* LOOP THROUGH VERTICES */
for(i=0;i<npnt;++i)
for(n=0;n<NV;++n)
ugbd(tlvl).v(i,n) = ibc->f(n,pnts(i),gbl->time);
if (basis::tet(log2p).em == 0) return;
/* LOOP THROUGH EDGES */
for(eind = 0; eind < nseg; ++eind) {
v0 = seg(eind).pnt(0);
v1 = seg(eind).pnt(1);
if (seg(eind).info < 0){
for(n=0;n<ND;++n)
basis::tet(log2p).proj1d(pnts(v0)(n),pnts(v1)(n),&crd1d(n)(0));
}
else {
crdtocht1d(eind,tlvl);
for(n=0;n<ND;++n)
basis::tet(log2p).proj1d(&cht(n)(0),&crd1d(n)(0));
}
for(n=0;n<NV;++n)
basis::tet(log2p).proj1d(ugbd(tlvl).v(v0,n),ugbd(tlvl).v(v1,n),&u1d(n)(0));
for(i=0;i<basis::tet(log2p).gpx; ++i) {
pt(0) = crd1d(0)(i);
pt(1) = crd1d(1)(i);
pt(2) = crd1d(2)(i);
for(n=0;n<NV;++n){
// difference between actual function and linear
u1d(n)(i) -= ibc->f(n,pt,gbl->time);
}
}
for(n=0;n<NV;++n)
basis::tet(log2p).intgrt1d(&lf(n)(0),&u1d(n)(0));
for(n=0;n<NV;++n) {
for(m=0;m<basis::tet(log2p).em;++m){
ugbd(tlvl).e(eind,m,n) = -lf(n)(2+m)*basis::tet(log2p).diag1d(m);
}
}
}
if (basis::tet(log2p).fm == 0) return;
/* LOOP THROUGH FACES */
for(find = 0; find < ntri; ++find) {
ugtouht2d_bdry(find,tlvl);
for(n=0;n<NV;++n)
basis::tet(log2p).proj2d_bdry(&uht(n)(0),&u2d(n)(0)(0),stridey);
if (tri(find).info < 0) {
for(n=0;n<ND;++n)
basis::tet(log2p).proj2d(vrtxbd(tlvl)(tri(find).pnt(0))(n),vrtxbd(tlvl)(tri(find).pnt(1))(n),vrtxbd(tlvl)(tri(find).pnt(2))(n),&crd2d(n)(0)(0),stridey);
}
else {
crdtocht2d(find,tlvl);
for(n=0;n<ND;++n)
basis::tet(log2p).proj2d_bdry(&cht(n)(0),&crd2d(n)(0)(0),stridey);
}
for (i=0; i < basis::tet(log2p).gpx; ++i ) {
for (j=0; j < basis::tet(log2p).gpy; ++j ) {
pt(0) = crd2d(0)(i)(j);
pt(1) = crd2d(1)(i)(j);
pt(2) = crd2d(2)(i)(j);
for(n=0;n<NV;++n) {
u2d(n)(i)(j) -= ibc->f(n,pt,gbl->time);
}
}
}
for(n=0;n<NV;++n) {
basis::tet(log2p).intgrt2d(&lf(n)(0),&u2d(n)(0)(0),stridey);
for(i=0;i<basis::tet(log2p).fm;++i){
ugbd(tlvl).f(find,i,n) = -lf(n)(3+3*basis::tet(log2p).em+i)*basis::tet(log2p).diag2d(i);
}
}
}
if (basis::tet(log2p).im == 0) return;
/* LOOP THROUGH TETS */
for(tind = 0; tind < ntet; ++tind) {
ugtouht_bdry(tind,tlvl);
for(n=0;n<NV;++n)
basis::tet(log2p).proj_bdry(&uht(n)(0),&u(n)(0)(0)(0),stridex,stridey);
if (tet(tind).info < 0) {
for(n=0;n<ND;++n)
basis::tet(log2p).proj(vrtxbd(tlvl)(tet(tind).pnt(0))(n),vrtxbd(tlvl)(tet(tind).pnt(1))(n),vrtxbd(tlvl)(tet(tind).pnt(2))(n),vrtxbd(tlvl)(tet(tind).pnt(3))(n),&crd(n)(0)(0)(0),stridex,stridey);
}
else {
crdtocht(tind,tlvl);
for(n=0;n<ND;++n)
basis::tet(log2p).proj_bdry(&cht(n)(0),&crd(n)(0)(0)(0),stridex,stridey);
}
for (i=0; i < basis::tet(log2p).gpx; ++i ) {
for (j=0; j < basis::tet(log2p).gpy; ++j ) {
for (k=0; k < basis::tet(log2p).gpz; ++k ) {
pt(0) = crd(0)(i)(j)(k);
pt(1) = crd(1)(i)(j)(k);
pt(2) = crd(2)(i)(j)(k);
for(n=0;n<NV;++n)
u(n)(i)(j)(k) -= ibc->f(n,pt,gbl->time);
}
}
}
for(n=0;n<NV;++n) {
basis::tet(log2p).intgrt(&lf(n)(0),&u(n)(0)(0)(0),stridex,stridey);
for(i=0;i<basis::tet(log2p).im;++i) {
ugbd(tlvl).i(tind,i,n) = -lf(n)(basis::tet(log2p).bm+i)*basis::tet(log2p).diag3d(i);
}
}
}
return;
}
void writeFrames(const Kinect::FrameSource::IntrinsicParameters& ip,const Kinect::FrameBuffer& color,const Kinect::MeshBuffer& mesh,const char* lwoFileName)
{
/* Create the texture file name: */
std::string textureFileName(lwoFileName,Misc::getExtension(lwoFileName));
textureFileName.append("-color.png");
/* Write the color frame as a texture image: */
{
Images::RGBImage texImage(color.getSize(0),color.getSize(1));
Images::RGBImage::Color* tiPtr=texImage.modifyPixels();
const unsigned char* cfPtr=reinterpret_cast<const unsigned char*>(color.getBuffer());
for(int y=0;y<color.getSize(1);++y)
for(int x=0;x<color.getSize(0);++x,++tiPtr,cfPtr+=3)
*tiPtr=Images::RGBImage::Color(cfPtr);
Images::writeImageFile(texImage,textureFileName.c_str());
}
/* Open the LWO file: */
IO::FilePtr lwoFile=IO::openFile(lwoFileName,IO::File::WriteOnly);
lwoFile->setEndianness(Misc::BigEndian);
/* Create the LWO file structure via the FORM chunk: */
{
IFFChunkWriter form(lwoFile,"FORM");
form.write<char>("LWO2",4);
/* Create the TAGS chunk: */
{
IFFChunkWriter tags(&form,"TAGS");
tags.writeString("ColorImage");
tags.writeChunk();
}
/* Create the LAYR chunk: */
{
IFFChunkWriter layr(&form,"LAYR");
layr.write<Misc::UInt16>(0U);
layr.write<Misc::UInt16>(0x0U);
for(int i=0;i<3;++i)
layr.write<Misc::Float32>(0.0f);
layr.writeString("DepthImage");
layr.writeChunk();
}
/* Create an index map for all vertices to omit unused vertices: */
unsigned int* indices=new unsigned int[mesh.numVertices];
for(unsigned int i=0;i<mesh.numVertices;++i)
indices[i]=~0x0U;
unsigned int numUsedVertices=0;
/* Create the PNTS, BBOX and VMAP chunks in one go: */
{
typedef Kinect::FrameSource::IntrinsicParameters::PTransform PTransform;
typedef PTransform::Point Point;
typedef Geometry::Box<Point::Scalar,3> Box;
IFFChunkWriter bbox(&form,"BBOX");
IFFChunkWriter pnts(&form,"PNTS");
IFFChunkWriter vmap(&form,"VMAP");
/* Write the VMAP header: */
vmap.write<char>("TXUV",4);
vmap.write<Misc::UInt16>(2U);
vmap.writeString("ColorImageUV");
/* Process all triangle vertices: */
Box pBox=Box::empty;
const Kinect::MeshBuffer::Vertex* vertices=mesh.getVertices();
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int i=0;i<mesh.numTriangles*3;++i,++tiPtr)
{
/* Check if the triangle vertex doesn't already have an index: */
if(indices[*tiPtr]==~0x0U)
{
/* Assign an index to the triangle vertex: */
indices[*tiPtr]=numUsedVertices;
/* Transform the mesh vertex to camera space using the depth projection matrix: */
Point dp(vertices[*tiPtr].position.getXyzw());
Point cp=ip.depthProjection.transform(dp);
/* Transform the depth-space point to texture space using the color projection matrix: */
Point tp=ip.colorProjection.transform(dp);
/* Add the point to the bounding box: */
pBox.addPoint(cp);
/* Store the point and its texture coordinates: */
pnts.writePoint(cp);
vmap.writeVarIndex(numUsedVertices);
for(int i=0;i<2;++i)
vmap.write<Misc::Float32>(tp[i]);
++numUsedVertices;
}
}
/* Write the bounding box: */
bbox.writeBox(pBox);
/* Write the BBOX, PNTS, and VMAP chunks: */
bbox.writeChunk();
pnts.writeChunk();
vmap.writeChunk();
}
/* Create the POLS chunk: */
{
IFFChunkWriter pols(&form,"POLS");
pols.write<char>("FACE",4);
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex,tiPtr+=3)
{
pols.write<Misc::UInt16>(3U);
for(int i=0;i<3;++i)
pols.writeVarIndex(indices[tiPtr[2-i]]);
}
pols.writeChunk();
}
/* Delete the vertex index map: */
delete[] indices;
/* Create the PTAG chunk: */
{
IFFChunkWriter ptag(&form,"PTAG");
ptag.write<char>("SURF",4);
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex)
{
ptag.writeVarIndex(triangleIndex);
ptag.write<Misc::UInt16>(0U);
}
ptag.writeChunk();
}
/* Create the CLIP chunk: */
{
IFFChunkWriter clip(&form,"CLIP");
clip.write<Misc::UInt32>(1U);
/* Create the STIL chunk: */
{
IFFChunkWriter stil(&clip,"STIL",true);
stil.writeString(textureFileName.c_str());
stil.writeChunk();
}
clip.writeChunk();
}
/* Create the SURF chunk: */
{
IFFChunkWriter surf(&form,"SURF");
surf.writeString("ColorImage");
surf.writeString("");
/* Create the SIDE subchunk: */
{
IFFChunkWriter side(&surf,"SIDE",true);
side.write<Misc::UInt16>(3U);
side.writeChunk();
}
/* Create the SMAN subchunk: */
{
IFFChunkWriter sman(&surf,"SMAN",true);
sman.write<Misc::Float32>(Math::rad(90.0f));
sman.writeChunk();
}
/* Create the COLR subchunk: */
{
IFFChunkWriter colr(&surf,"COLR",true);
colr.writeColor(1.0f,1.0f,1.0f);
colr.writeVarIndex(0U);
colr.writeChunk();
}
/* Create the DIFF subchunk: */
{
IFFChunkWriter diff(&surf,"DIFF",true);
diff.write<Misc::Float32>(1.0f);
diff.writeVarIndex(0U);
diff.writeChunk();
}
/* Create the LUMI subchunk: */
{
IFFChunkWriter lumi(&surf,"LUMI",true);
lumi.write<Misc::Float32>(0.0f);
lumi.writeVarIndex(0U);
lumi.writeChunk();
}
/* Create the BLOK subchunk: */
{
IFFChunkWriter blok(&surf,"BLOK",true);
/* Create the IMAP subchunk: */
{
IFFChunkWriter imap(&blok,"IMAP",true);
imap.writeString("1");
/* Create the CHAN subchunk: */
{
IFFChunkWriter chan(&imap,"CHAN",true);
chan.write<char>("COLR",4);
chan.writeChunk();
}
imap.writeChunk();
}
/* Create the PROJ subchunk: */
{
IFFChunkWriter proj(&blok,"PROJ",true);
proj.write<Misc::UInt16>(5U);
proj.writeChunk();
}
/* Create the IMAG subchunk: */
{
IFFChunkWriter imag(&blok,"IMAG",true);
imag.writeVarIndex(1U);
imag.writeChunk();
}
/* Create the VMAP subchunk: */
{
IFFChunkWriter vmap(&blok,"VMAP",true);
vmap.writeString("ColorImageUV");
vmap.writeChunk();
}
blok.writeChunk();
}
/* Write the SURF chunk: */
surf.writeChunk();
}
/* Write the FORM chunk: */
form.writeChunk();
}
}
void Draw_Arrow::drawImage(QPainter *painter,QString &text,QPointF point)
{
QPainterPath arrow;
QString str_x,str_y,str_x1,str_y1;
QString color_r,color_g,color_b;
QPointF pnt;
QVector<QPointF> pnts(arrow_pnts.size());
/*if(item->pos()!=QPointF(0,0))
{
StrtPnt=item->sceneBoundingRect().topLeft();
arrow_pnts[0]=StrtPnt;
pnt.setX(StrtPnt.x()+25);
pnt.setY(StrtPnt.y());
arrow_pnts[1]=pnt;
pnt.setX(StrtPnt.x()+25);
pnt.setY(StrtPnt.y()-25);
arrow_pnts[2]=pnt;
pnt.setX(StrtPnt.x()+50);
pnt.setY(StrtPnt.y()+25);
arrow_pnts[3]=pnt;
pnt.setX(StrtPnt.x()+25);
pnt.setY(StrtPnt.y()+75);
arrow_pnts[4]=pnt;
pnt.setX(StrtPnt.x()+25);
pnt.setY(StrtPnt.y()+50);
arrow_pnts[5]=pnt;
pnt.setX(StrtPnt.x());
pnt.setY(StrtPnt.y()+50);
arrow_pnts[6]=pnt;
arrow_pnts[7]=StrtPnt;
EndPnt=item->sceneBoundingRect().bottomRight();
}*/
for(int i=0;i<pnts.size();i++)
{
qDebug()<<"arrow pnts "<<arrow_pnts[i]<<"\n";
pnts[i]=arrow_pnts[i];
pnts[i]+=point;
}
painter->setPen(this->pen);
painter->setBrush(this->brush);
arrow.addPolygon(QPolygonF(pnts));
painter->drawPath(arrow);
text+="Arrow\n";
text+="Coords";
text+=" "+str_x.setNum(arrow_pnts.size()*2);
qDebug()<<"number of points "<<arrow_pnts.size()*2<<"\n";
for(int j=0;j<this->arrow_pnts.size();j++)
{
text+=" "+str_x.setNum((arrow_pnts[j].x()))+" "+str_y.setNum((arrow_pnts[j].y()))+" ";
}
text+="PenColor";
text+=" "+color_r.setNum(this->pen.color().red())+" "+color_g.setNum(this->pen.color().green())+" "+color_b.setNum(this->pen.color().blue())+"\n";
text+="PenStyle";
text+=" "+color_r.setNum(this->pen.style())+"\n";
text+="PenWidth";
text+=" "+color_r.setNum(this->pen.width())+"\n";
text+="BrushColor";
text+=" "+color_r.setNum(this->brush.color().red())+" "+color_g.setNum(this->brush.color().green())+" "+color_b.setNum(this->brush.color().blue())+"\n";
text+="BrushStyle";
text+=" "+color_r.setNum(this->brush.style())+"\n";
text+="Rotation";
text+=" "+color_r.setNum(this->item->rotation(),'g',6)+"\n";
}
//===== Load A Point =====//
void bicubic_surf::put_pnt(int ind_u, int ind_w, const vec3d& pnt_in)
{
pnts(ind_u,ind_w) = pnt_in;
}
//===== Compute Tangents Using Forward and Reverse Difference Method =====//
void herm_curve::comp_tans()
{
int i = 0;
float temp_dist1 = 0.0, temp_dist2 = 0.0;
Dyn_array_dbl dist_mag;
dist_mag.set_chunk_size(num_pnts);
dist_mag.init(num_pnts);
for ( i = 1 ; i < num_pnts-1 ; i++)
{
temp_dist1 = (float) (pnts(i) - pnts(i+1)).mag();
temp_dist2 = (float) (pnts(i-1) - pnts(i)).mag();
if ( temp_dist1 < temp_dist2)
dist_mag(i) = temp_dist1;
else
dist_mag(i) = temp_dist2;
}
temp_dist1 = (float) (pnts(1) - pnts(0)).mag();
temp_dist2 = (float) (pnts(num_pnts-2) - pnts(0)).mag();
if ( temp_dist1 < temp_dist2)
dist_mag(0) = temp_dist1;
else
dist_mag(0) = temp_dist2;
dist_mag(num_pnts-1) = dist_mag(0);
if (open_closed_flag == OPEN_CURVE)
{
tans(0) = pnts(1) - pnts(0);
tans(num_pnts-1) = pnts(num_pnts-1) - pnts(num_pnts-2);
}
else
{
tans(0) = pnts(1) - pnts(num_pnts-2);
tans(0).normalize();
tans(0) = tans(0) * dist_mag(0);
tans(num_pnts-1) = tans(0);
}
for ( i = 1 ; i < num_pnts-1 ; i++)
{
tans(i) = pnts(i+1) - pnts(i-1);
tans(i).normalize();
tans(i) = tans(i) * dist_mag(i);
}
for ( i = 0 ; i < num_pnts ; i++)
{
tans(i) = tans(i)*tan_k(i);
}
}
//===== Compute A Tangent Given Intermediate Point and U =====//
void bicubic_surf::comp_tans()
{
int i,j;
for ( i = 0 ; i < num_pnts_u ; i++)
{
if (open_closed_flag_w == OPEN)
{
tanw(i,0) = pnts(i,1) - pnts(i,0);
tanw(i,num_pnts_w-1) = pnts(i,num_pnts_w-1) - pnts(i,num_pnts_w-2);
}
else
{
tanw(i,0) = pnts(i,1) - pnts(i,num_pnts_w-2);
tanw(i,num_pnts_w-1) = tanw(i,0);
}
for ( j = 1 ; j < num_pnts_w-1 ; j++)
{
tanw(i,j) = pnts(i,j+1) - pnts(i,j-1);
}
}
for ( j = 0 ; j < num_pnts_w ; j++)
{
if (open_closed_flag_u == OPEN)
{
tanu(0,j) = pnts(1,j) - pnts(0,j);
tanu(num_pnts_u-1,j) = pnts(num_pnts_u-1,j) - pnts(num_pnts_u-2,j);
}
else
{
tanu(0,j) = pnts(1,j) - pnts(num_pnts_u-2,j);
tanu(num_pnts_u-1,j) = tanu(0,j);
}
for ( i = 1 ; i < num_pnts_u-1 ; i++)
{
tanu(i,j) = pnts(i+1,j) - pnts(i-1,j);
}
}
for ( i = 0 ; i < num_pnts_u ; i++)
{
for ( j = 0 ; j < num_pnts_w ; j++)
{
tanu(i,j) = tanu(i,j)*tanu_k(i,j);
tanw(i,j) = tanw(i,j)*tanw_k(i,j);
}
}
}
