std::vector<std::string> StrainMeasures::getSegmentStrains(std::string fieldName) {
std::vector<std::string> strains(19);
Cmiss_field_id field = Cmiss_field_module_find_field_by_name(field_module, fieldName.c_str());
//Compute strains
unsigned int numSegments = mySegments->size();
double temp_array1[3];
double temp_array2[3];
//#define printcoord
#ifdef printcoord
#include "MeshTopology.h"
std::vector<Cmiss_node_id> myNodes(100);
Cmiss_nodeset_id nodeset = Cmiss_field_module_find_nodeset_by_name(field_module, "cmiss_nodes");
Cmiss_node_iterator_id nodeIterator = Cmiss_nodeset_create_node_iterator(nodeset);
Cmiss_node_id node = Cmiss_node_iterator_next(nodeIterator);
if (node != 0) {
double temp_array[3];
while (node) {
int node_id = Cmiss_node_get_identifier(node);
myNodes[node_id - 1] = node;
node = Cmiss_node_iterator_next(nodeIterator);
}
}
Cmiss_nodeset_destroy(&nodeset);
Cmiss_node_iterator_destroy(&nodeIterator);
std::vector<int> Nodes(27);
Nodes[8] = aplaxNodes8;
Nodes[7] = aplaxNodes7;
Nodes[6] = aplaxNodes6;
Nodes[5] = aplaxNodes5;
Nodes[4] = aplaxNodes4;
Nodes[3] = aplaxNodes3;
Nodes[2] = aplaxNodes2;
Nodes[1] = aplaxNodes1;
Nodes[0] = aplaxNodes0;
Nodes[9] = tchNodes0;
Nodes[10] = tchNodes1;
Nodes[11] = tchNodes2;
Nodes[12] = tchNodes3;
Nodes[13] = tchNodes4;
Nodes[14] = tchNodes5;
Nodes[15] = tchNodes6;
Nodes[16] = tchNodes7;
Nodes[17] = tchNodes8;
Nodes[18] = fchNodes0;
Nodes[19] = fchNodes1;
Nodes[20] = fchNodes2;
Nodes[21] = fchNodes3;
Nodes[22] = fchNodes4;
Nodes[23] = fchNodes5;
Nodes[24] = fchNodes6;
Nodes[25] = fchNodes7;
Nodes[26] = fchNodes8;
#endif
std::vector<std::vector<double> > aplaxLengths;
std::vector<std::vector<double> > tchLengths;
std::vector<std::vector<double> > fchLengths;
double denomj = (numberOfModelFrames_ - 1.0);
for (int i = 0; i < numberOfModelFrames_; i++) {
std::vector<double> cLengths;
double time = ((double) i) / denomj;
Cmiss_field_cache_set_time(fieldCache, time);
#ifdef printcoord
std::cout<<"Frame "<<i<<"\t"<<time<<"\t"<<mySegments->at(0).xia[2]<<std::endl;
#endif
for (int j = 0; j < numSegments; j++) {
WallSegment& seg = mySegments->at(j);
//The the lengths
temp_array1[0] = temp_array1[1] = temp_array1[2] = 0.0;
temp_array2[0] = temp_array2[1] = temp_array2[2] = 0.0;
//Since cmiss id starts at 1 subtract 1 from seg.elemeid?
//Note that accessing some computed field (those that involve gradients), with multiple versions leads to gradient set to 0 warning
Cmiss_field_cache_set_mesh_location(fieldCache, elements[seg.elementida - 1], 3, seg.xia);
Cmiss_field_evaluate_real(field, fieldCache, 3, temp_array1);
Cmiss_field_cache_set_mesh_location(fieldCache, elements[seg.elementidb - 1], 3, seg.xib);
Cmiss_field_evaluate_real(field, fieldCache, 3, temp_array2);
Point3D p1(temp_array1);
Point3D p2(temp_array2);
double dist = p1.distance(p2);
#ifdef printcoord
{
int nodeCtr = (j / 8) * 9 + j % 8;
Cmiss_field_cache_set_node(fieldCache, myNodes[Nodes[nodeCtr]]);
temp_array1[0] = temp_array1[1] = temp_array1[2] = 0.0;
Cmiss_field_evaluate_real(field, fieldCache, 3, temp_array1);
Point3D p3(temp_array1);
Cmiss_field_cache_set_node(fieldCache, myNodes[Nodes[nodeCtr + 1]]);
temp_array1[0] = temp_array1[1] = temp_array1[2] = 0.0;
Cmiss_field_evaluate_real(field, fieldCache, 3, temp_array1);
Point3D p4(temp_array1);
std::cout << p1 << "\t" << p2 << " = " << dist << "\t:\t Value at " << Nodes[nodeCtr] + 1 << "\t" << p3 << "\t" << p1.distance(p3) << "\t" << Nodes[nodeCtr + 1] + 1
<< "\t" << p4 << "\t" << p2.distance(p4) << "\t distance \t " << p3.distance(p4) << std::endl;
}
#endif
cLengths.push_back(dist);
}
for (int segc = 0; segc < numSegments / 8; segc++) {
int offset = segc * 8;
std::vector<double> sLengths;
sLengths.push_back(cLengths[0 + offset] + (1 / 3.0 - 1 / 4.0) * 4 * cLengths[1 + offset]);
sLengths.push_back((1.0 - (1 / 3.0 - 1 / 4.0)) * 4 * cLengths[1 + offset] + (2 / 3.0 - 1 / 2.0) * 4 * cLengths[2 + offset]);
sLengths.push_back((1.0 - (2 / 3.0 - 1 / 2.0)) * 4 * cLengths[2 + offset] + cLengths[3 + offset]);
sLengths.push_back(cLengths[4 + offset] + (1.0 - (2 / 3.0 - 1 / 2.0)) * 4 * cLengths[5 + offset]);
sLengths.push_back((2 / 3.0 - 1 / 2.0) * 4 * cLengths[5 + offset] + (1.0 - (1 / 3.0 - 1 / 4.0)) * 4 * cLengths[6 + offset]);
sLengths.push_back((1 / 3.0 - 1 / 4.0) * 4 * cLengths[6 + offset] + cLengths[7 + offset]);
if (segc == 0)
aplaxLengths.push_back(sLengths);
else if (segc == 1)
tchLengths.push_back(sLengths);
else
fchLengths.push_back(sLengths);
}
}
std::vector<double> avgStrains(numberOfModelFrames_, 0.0);
for (int segc = 0; segc < numSegments / 8; segc++) {
std::vector<std::vector<double> > dstrains;
std::vector<std::vector<double> > distances;
if (segc == 0)
distances = aplaxLengths;
else if (segc == 1)
distances = tchLengths;
else if (segc == 2)
distances = fchLengths;
std::vector<double>& initStrain = distances[0];
for (int frame = 1; frame < numberOfModelFrames_; frame++) { //Compute Strains
std::vector<double>& curStrainLengths = distances[frame];
std::vector<double> curStrain;
double c = 0;
unsigned int ulimit = initStrain.size();
for (int j = 0; j < ulimit; j++) {
c = 100.0 * (curStrainLengths[j] - initStrain[j]) / initStrain[j];
curStrain.push_back(c);
}
dstrains.push_back(curStrain);
}
std::vector<std::string> strainSeries;
for (int j = 0; j < initStrain.size(); j++) {
std::ostringstream ss;
ss << 0.0; //For init step
int denom = numberOfModelFrames_ - 1;
double maxStrain = dstrains[denom - 1][j];
//Note that frame goes from 1 to heart.numberOfModelFrames_ when computing strain
//so shift down by 1
for (int i = 0; i < denom; i++) { //Compute Strains
//Drift compensate
double stc = dstrains[i][j] - (i + 1) * maxStrain / denom;
ss << "," << stc;
avgStrains[i] += stc;
}
strainSeries.push_back(ss.str());
}
if (segc == 0) {
strains[2 - 1] = strainSeries[5];
strains[8 - 1] = strainSeries[4];
strains[17 - 1] = strainSeries[3];
strains[18 - 1] = strainSeries[2];
strains[11 - 1] = strainSeries[1];
strains[5 - 1] = strainSeries[0];
} else if (segc == 2) {
strains[3 - 1] = strainSeries[0];
strains[9 - 1] = strainSeries[1];
strains[14 - 1] = strainSeries[2];
strains[16 - 1] = strainSeries[3];
strains[12 - 1] = strainSeries[4];
strains[6 - 1] = strainSeries[5];
} else if (segc == 1) {
strains[4 - 1] = strainSeries[0];
strains[10 - 1] = strainSeries[1];
strains[15 - 1] = strainSeries[2];
strains[13 - 1] = strainSeries[3];
strains[7 - 1] = strainSeries[4];
strains[1 - 1] = strainSeries[5];
}
}
#ifdef printcoord
std::cout << "Linear 3D " << fieldName << std::endl;
for (int i = 1; i < 100; i++)
Cmiss_node_destroy(&myNodes[i]);
#endif
//Add the average strain
//Num strain segments depends on the number of active segments (6 strain segments per view, which has 8 active segments)
double denom = (numSegments / 8) * 6;
std::ostringstream ss;
ss << 0.0; //For init step
for (int i = 0; i < numberOfModelFrames_ - 1; i++) { //Compute the Average
ss << "," << avgStrains[i] / denom;
}
strains[18] = ss.str();
//Check if model PGS should be calculated
if (computeModelPGS) {
double max = fabs(avgStrains[0]);
int idx = 0;
for (int i = 1; i < numberOfModelFrames_ - 1; i++) {
if (fabs(avgStrains[i]) > max) {
max = fabs(avgStrains[i]);
idx = i;
}
}
modelPGS = avgStrains[idx] / denom;
computeModelPGS = false; //set it so that it is not computed in subsequent calls
}
Cmiss_field_destroy(&field);
return strains;
}
//////////////////////////////////////////////////////////////////////
// Private services Functions
//////////////////////////////////////////////////////////////////////
GLC_3DViewInstance GLC_RepCrossMover::createCrossInstance()
{
GLC_Polylines* pCross= new GLC_Polylines();
int nLgAxe;
const int winHSize= m_pViewport->viewHSize();
const int winVSize= m_pViewport->viewVSize();
if (winHSize > winVSize)
{
nLgAxe = static_cast<int>(static_cast<double>(winVSize) / 2.0);
}
else
{
nLgAxe = static_cast<int>(static_cast<double>(winHSize) / 2.0);
}
// Compute the length of camera's field of view
const double ChampsVision = 2 * (m_pViewport->cameraHandle()->distEyeTarget()) * tan((m_pViewport->viewAngle() * glc::PI / 180.0) / 2.0);
// the side of camera's square is mapped on Vertical length of window
// Axis length in OpenGL unit = length(Pixel) * (dimend GL / dimens Pixel)
const double dLgAxe= ((double)nLgAxe * ChampsVision / (double)winVSize) / 7;
const double dDecAxe= dLgAxe / 3;
//X axis
{
GLC_Point3d p1(-dLgAxe, 0, 0);
GLC_Point3d p2(-dDecAxe, 0, 0);
GLC_Point3d p3(dDecAxe, 0, 0);
GLC_Point3d p4(dLgAxe, 0, 0);
QList<GLC_Point3d> points;
points << p1 << p2 << p3 << p4;
pCross->addPolyline(points);
}
//Y axis
{
GLC_Point3d p1(0, -dLgAxe, 0);
GLC_Point3d p2(0, -dDecAxe, 0);
GLC_Point3d p3(0, dDecAxe, 0);
GLC_Point3d p4(0, dLgAxe, 0);
QList<GLC_Point3d> points;
points << p1 << p2 << p3 << p4;
pCross->addPolyline(points);
}
//Z axis
{
GLC_Point3d p1(0, 0, -dLgAxe);
GLC_Point3d p2(0, 0, -dDecAxe);
GLC_Point3d p3(0, 0, dDecAxe);
GLC_Point3d p4(0, 0, dLgAxe);
QList<GLC_Point3d> points;
points << p1 << p2 << p3 << p4;
pCross->addPolyline(points);
}
pCross->setWireColor(m_MainColor);
GLC_3DViewInstance crossInstance(pCross);
GLC_Matrix4x4 translation;
translation.setMatTranslate(m_pViewport->cameraHandle()->target());
crossInstance.setMatrix(translation);
return crossInstance;
}
void CContainers::prepareMemBuffers()
{
memout=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p("!data",memout);
memmap.insert(p);
memout_words=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p2("!!!words",memout_words);
memmap.insert(p2);
memout_letters=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p3("!!letters",memout_letters);
memmap.insert(p3);
memout_num=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p4("!num",memout_num);
memmap.insert(p4);
memout_year=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p5("!year",memout_year);
memmap.insert(p5);
memout_date=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p6("!date",memout_date);
memmap.insert(p6);
memout_words2=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p7("!!!words2",memout_words2);
memmap.insert(p7);
memout_words3=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p8("!!!words3",memout_words3);
memmap.insert(p8);
memout_words4=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p9("!!!words4",memout_words4);
memmap.insert(p9);
memout_pages=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p10("!pages",memout_pages);
memmap.insert(p10);
memout_num2=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p11("!num2",memout_num2);
memmap.insert(p11);
memout_num3=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p12("!num3",memout_num3);
memmap.insert(p12);
memout_num4=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p13("!num4",memout_num4);
memmap.insert(p13);
memout_remain=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p14("!remain",memout_remain);
memmap.insert(p14);
memout_date2=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p15("!date2",memout_date2);
memmap.insert(p15);
memout_date3=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p16("!date3",memout_date3);
memmap.insert(p16);
memout_num2b=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p17("!num2b",memout_num2b);
memmap.insert(p17);
memout_num3b=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p18("!num3b",memout_num3b);
memmap.insert(p18);
memout_num4b=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p19("!num4b",memout_num4b);
memmap.insert(p19);
memout_numb=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p20("!numb",memout_numb);
memmap.insert(p20);
memout_num2c=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p21("!num2c",memout_num2c);
memmap.insert(p21);
memout_num3c=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p22("!num3c",memout_num3c);
memmap.insert(p22);
memout_num4c=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p23("!num4c",memout_num4c);
memmap.insert(p23);
memout_numc=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p24("!numc",memout_numc);
memmap.insert(p24);
memout_time=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p25("!time",memout_time);
memmap.insert(p25);
memout_remain2=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p26("!remain2",memout_remain2);
memmap.insert(p26);
memout_ip=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p27("!ip",memout_ip);
memmap.insert(p27);
memout_hm=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p28("!hm",memout_hm);
memmap.insert(p28);
memout_hms=new CMemoryBuffer();
std::pair<std::string,CMemoryBuffer*> p29("!hms",memout_hms);
memmap.insert(p29);
}
void RedlineExtractorNode::generateMsg (void)
{
double step = 100;
double x1, x2, a1, a2, y1, y2, b1, b2;
this->output.lineMsg.lineOneFound = false;
this->output.lineMsg.lineTwoFound = false;
this->output.lineMsg.angle = .0;
this->output.lineMsg.lineOne.clear();
this->output.lineMsg.lineOne.push_back(.0);
this->output.lineMsg.lineOne.push_back(.0);
this->output.lineMsg.lineOne.push_back(.0);
this->output.lineMsg.lineOne.push_back(.0);
this->output.lineMsg.lineTwo.clear();
this->output.lineMsg.lineTwo.push_back(.0);
this->output.lineMsg.lineTwo.push_back(.0);
this->output.lineMsg.lineTwo.push_back(.0);
this->output.lineMsg.lineTwo.push_back(.0);
// this->output.lineMsg.lineTwo = [.0,.0,.0,.0];
if (this->models.lineOneFound)
{
x1 = this->models.lineOne.coeff(0),
x2 = this->models.lineOne.coeff(1),
a1 = this->models.lineOne.coeff(3),
a2 = this->models.lineOne.coeff(4);
cv::Point p1(x1 - step * a1, x2 - step * a2), p2(x1 + step * a1, x2 + step * a2);
cv::line(this->poiImage, p1, p2, cv::Scalar(0,0,255));
this->output.lineMsg.lineOneFound = true;
this->output.lineMsg.lineOne.clear();
this->output.lineMsg.lineOne.push_back(x1);
this->output.lineMsg.lineOne.push_back(x2);
this->output.lineMsg.lineOne.push_back(a1);
this->output.lineMsg.lineOne.push_back(a2);
}
if (this->models.lineTwoFound)
{
y1 = this->models.lineTwo.coeff(0),
y2 = this->models.lineTwo.coeff(1),
b1 = this->models.lineTwo.coeff(3),
b2 = this->models.lineTwo.coeff(4);
cv::Point p3(y1 - step * b1, y2 - step * b2), p4(y1 + step * b1, y2 + step * b2);
cv::line(this->poiImage, p3, p4, cv::Scalar(0,255,0));
this->output.lineMsg.lineTwoFound = true;
this->output.lineMsg.lineTwo.clear();
this->output.lineMsg.lineTwo.push_back(y1);
this->output.lineMsg.lineTwo.push_back(y2);
this->output.lineMsg.lineTwo.push_back(b1);
this->output.lineMsg.lineTwo.push_back(b2);
}
if (this->models.lineOneFound && this->models.lineTwoFound)
this->output.lineMsg.angle = std::acos(a1 * b1 + a2 * b2) * 180.0 / M_PI;
// Convert data
pcl::toROSMsg(this->poiCloud, this->output.poiCloudMsg);
}
void test_RT()
{
typedef RT Cls;
// _test_cls_regular_3( Cls() );
typedef traits::Bare_point Point;
typedef traits::Weighted_point Weighted_point;
typedef typename Cls::Vertex_handle Vertex_handle;
typedef typename Cls::Cell_handle Cell_handle;
typedef typename Cls::Facet Facet;
typedef typename Cls::Edge Edge;
typedef std::list<Weighted_point> list_point;
typedef typename Cls::Finite_cells_iterator Finite_cells_iterator;
// temporary version
int n, m;
int count = 0;
// For dimension 0, we need to check that the point of highest weight is the
// one that finally ends up in the vertex.
std::cout << " test dimension 0 " << std::endl;
Cls T0;
T0.insert(Weighted_point( Point (0,0,0), 0) );
T0.insert(Weighted_point( Point (0,0,0), 1) );
T0.insert(Weighted_point( Point (0,0,0), -1) );
assert(T0.dimension() == 0);
assert(T0.number_of_vertices() == 1);
assert(T0.finite_vertices_begin()->point().weight() == 1);
std::cout << " test dimension 1 " << std::endl;
Cls T1;
std::cout << " number of inserted points : " ;
Weighted_point p[5];
for ( m=0; m<5; m++) {
if ( (m%2)== 0 )
p[m] = Weighted_point( Point( 2*m,0,0 ), 2 );
else
p[m] = Weighted_point( Point( -2*m+1,0,0 ), 2 );
T1.insert( p[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
std::cout << " number of inserted points : " ;
Weighted_point q[5];
for ( m=0; m<5; m++) {
if ( (m%2)== 0 )
q[m] = Weighted_point( Point( 2*m+1,0,0 ), 5 );
else
q[m] = Weighted_point( Point( -2*m+1,0,0 ), 5 );
T1.insert( q[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
std::cout << " number of inserted points : " ;
Weighted_point r[10];
for ( m=0; m<10; m++) {
if ( (m%2)== 0 )
r[m] = Weighted_point( Point( m,0,0 ), 1 );
else
r[m] = Weighted_point( Point( -m,0,0 ), 1 );
T1.insert( r[m] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
assert( T1.is_valid() );
std::cout << std::endl << " number of vertices : "
<< T1.number_of_vertices() << std::endl;
assert( T1.dimension()==1 );
// The following is distilled from a bug report by Wulue Zhao
// ([email protected]), a student of Tamal Dey.
Point pt0(0,0,0);
Point pt1( 1,0,0), pt2(2,0,0), pt3(3,0,0);
Point pt4(-1,0,0), pt5(-2,0,0), pt6(-3,0,0);
Weighted_point wp0(pt0,10.0);
Weighted_point wp1(pt1,0.0), wp2(pt2,0.0), wp3(pt3,0.0);
Weighted_point wp4(pt4,0.0), wp5(pt5,0.0), wp6(pt6,0.0);
Cls T11;
T11.insert(wp0);
T11.insert(wp1);
T11.insert(wp2);
T11.insert(wp3);
T11.insert(wp4);
T11.insert(wp5);
T11.insert(wp6);
assert(T11.is_valid());
// And another distilled bug report from the same guy.
{
Point p1(-0.07, 0.04, 0.04);
Point p2(0.09, 0.04, 0.04);
Point p3(0.09, -0.05, 0.04);
Point p4(0.05, -0.05, 0.04);
Point p5(0.05, 0.0, 0.04);
Point p6(-0.07, 0.0, 0.04);
Point p7(-0.07, 0.04, -0.04);
Point p8(0.09, 0.04, -0.04);
Point p9(0.09, -0.05, -0.04);
Point p10(0.05, -0.05, -0.04);
Point p11(0.05, 0.0, -0.04);
Point p12(-0.07, 0.0, -0.04);
Weighted_point wp1(p1,0);
Weighted_point wp2(p2,0);
Weighted_point wp3(p3,0);
Weighted_point wp4(p4,0);
Weighted_point wp5(p5,0);
Weighted_point wp6(p6,0);
Weighted_point wp7(p7,0);
Weighted_point wp8(p8,0);
Weighted_point wp9(p9,0);
Weighted_point wp10(p10,0);
Weighted_point wp11(p11,0);
Weighted_point wp12(p12,0);
Weighted_point wp13(p3,0.3); // wp13 has the same coordinates with wp3
Cls T111;
T111.insert(wp1);
T111.insert(wp2);
T111.insert(wp3);
T111.insert(wp13); // it doesnot work inserting wp13 here
T111.insert(wp4);
T111.insert(wp5);
T111.insert(wp6);
T111.insert(wp7);
T111.insert(wp8);
T111.insert(wp9);
T111.insert(wp10);
T111.insert(wp11);
T111.insert(wp12);
assert(T111.is_valid());
}
std::cout << " test dimension 2 " << std::endl;
std::cout << " number of inserted points : " ;
Cls T2;
count = 0 ;
int px=1, py=1;
int qx=-1, qy=2;
Weighted_point s[400];
for (m=0; m<10; m++)
for (n=0; n<10; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), 1 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=10; m<20; m++)
for (n=0; n<10; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), -1 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=0; m<10; m++)
for (n=10; n<20; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), -2 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
for (m=10; m<20; m++)
for (n=10; n<20; n++) {
s[m+20*n] = Weighted_point( Point(m*px+n*qx, m*py+n*qy, 0), 5 );
T2.insert( s[m+20*n] );
count++;
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
std::cout << count << '\b' << '\b' << '\b' ;
std::cout.flush();
}
std::cout << std::endl << " number of vertices : "
<< T2.number_of_vertices() << std::endl;
assert( T2.dimension()==2 );
assert( T2.is_valid() );
// dimension 3
std::cout << " test dimension 3" << std::endl;
Cls T;
list_point lp;
int a, b, d;
for (a=0;a!=10;a++)
// for (b=0;b!=10;b++)
for (b=0;b!=5;b++)
// for (d=0;d!=10;d++)
for (d=0;d!=5;d++)
lp.push_back(Weighted_point( Point(a*b-d*a + (a-b)*10 +a ,
a-b+d +5*b,
a*a-d*d+b),
a*b-a*d) );
list_point::iterator it;
count = 0 ;
std::cout << " number of inserted points : " ;
for (it=lp.begin(); it!=lp.end(); ++it){
count++;
T.insert(*it);
if (count <10)
std::cout << count << '\b' ;
else
if (count < 100)
std::cout << count << '\b' << '\b' ;
else
if (count < 1000)
std::cout << count << '\b' << '\b' << '\b' ;
else
std::cout << count << std::endl;
std::cout.flush();
}
std::cout << std::endl;
std::cout << " number of vertices : "
<< T.number_of_vertices() << std::endl;
assert(T.is_valid());
assert(T.dimension()==3);
T.clear();
std::cout << " test iterator range insert" << std::endl;
T.insert (lp.begin(), lp.end());
std::cout << " number of vertices : "
<< T.number_of_vertices() << std::endl;
assert(T.is_valid());
assert(T.dimension()==3);
//test nearest_power_vertex
std::cout << " test nearest_power_vertex " << std::endl;
Point pp1(0.0, 0.0, 0.0);
Point pp2(1.0, 0.0, 0.0);
Point pp3(0.0, 1.0, 0.0);
Point pp4(0.0, 0.0, 1.0);
Point pp5(1.0, 1.0, 0.0);
Point pp6(0.0, 1.0, 1.0);
Point pp7(1.0, 0.0, 1.0);
Point pp8(1.0, 1.0, 1.0);
Weighted_point wpp1(pp1, 1.0);
Weighted_point wpp2(pp2, 2.0);
Weighted_point wpp3(pp3, 1.0);
Weighted_point wpp4(pp4, 4.0);
Weighted_point wpp5(pp5, 1.0);
Weighted_point wpp6(pp6, 1.0);
Weighted_point wpp7(pp7, 1.0);
Weighted_point wpp8(pp8, 8.0);
Cls T3;
T3.insert(wpp1);
Vertex_handle v2 = T3.insert(wpp2);
assert( T3.nearest_power_vertex(Point(0.5,0.5,0.5)) == v2);
T3.insert(wpp3);
Vertex_handle v4 = T3.insert(wpp4);
assert( T3.nearest_power_vertex(Point(0.5,0.5,0.5)) == v4);
T3.insert(wpp5);
T3.insert(wpp6);
T3.insert(wpp7);
// Avoid inserting the same point twice, now that hidden points are handled,
// insert (existing_point) returns Vertex_handle().
// T3.insert(wpp8);
Vertex_handle v8 = T3.insert(wpp8);
Point query(0.5,0.5,0.5);
assert(T3.nearest_power_vertex(query) == v8);
assert(T3.nearest_power_vertex(Weighted_point(query,1.0)) == v8 );
assert(T3.nearest_power_vertex_in_cell(query ,v8->cell()) == v8);
// test dual
std::cout << " test dual member functions" << std::endl;
Finite_cells_iterator fcit = T3.finite_cells_begin();
for( ; fcit != T3.finite_cells_end(); ++fcit) {
Point cc = T3.dual(fcit);
Vertex_handle ncc = T3.nearest_power_vertex(cc);
assert(fcit->has_vertex(ncc));
}
// test Gabriel
std::cout << " test is_Gabriel " << std::endl;
Point q0(0.,0.,0.);
Point q1(2.,0.,0.);
Point q2(0.,2.,0.);
Point q3(0.,0.,2.);
Weighted_point wq0(q0,0.);
Weighted_point wq1(q1,0.);
Weighted_point wq2(q2,0.);
Weighted_point wq3(q3,0.);
Weighted_point wq01(q0,2.);
Cls T4;
Vertex_handle v0 = T4.insert(wq0);
Vertex_handle v1 = T4.insert(wq1);
v2 = T4.insert(wq2);
Vertex_handle v3 = T4.insert(wq3);
Cell_handle c;
int i,j,k,l;
assert(T4.is_facet(v0,v1,v2,c,j,k,l));
i = 6 - (j+k+l);
Facet f = std::make_pair(c,i);
assert(T4.is_Gabriel(c,i));
assert(T4.is_Gabriel(f));
assert(T4.is_facet(v1,v2,v3,c,j,k,l));
i = 6 - (j+k+l);
assert(!T4.is_Gabriel(c,i));
assert(T4.is_edge(v0,v1,c,i,j));
assert(T4.is_Gabriel(c,i,j));
Edge e = make_triple(c,i,j);
assert(T4.is_Gabriel(e));
assert(T4.is_edge(v2,v3,c,i,j));
assert(T4.is_Gabriel(c,i,j));
Vertex_handle v01 = T4.insert(wq01);
(void) v01; // kill warning
assert(T4.is_edge(v2,v3,c,i,j));
assert(!T4.is_Gabriel(c,i,j));
Weighted_point wwq0(q0,0.);
Weighted_point wwq1(q1,0.);
Weighted_point wwq2(q2,0.);
Weighted_point wwq3(q3,5.);
Cls T5;
v0 = T5.insert(wwq0);
v1 = T5.insert(wwq1);
v2 = T5.insert(wwq2);
v3 = T5.insert(wwq3);
assert(T5.nearest_power_vertex(v3->point().point()) == v3);
assert(T5.nearest_power_vertex(v0->point().point()) == v3);
assert(T5.is_Gabriel(v3));
assert(!T5.is_Gabriel(v0));
}
/**
* Draw a cube into the verticies buffer. Draws the cube in the x-z plane at
* the specified row and column with a set height and color.
*
* In most cases, the texture coordinates are the same as the offsets for the cube
* vertex coordinates. Minor exception for left and right side to ensure texture
* is not sideways.
*
* @param x coordinate location
* @param y coordinate location
* @param z coordinate location
* @param size cube scaling size
* @param side cube side to draw
* @param type tile type to draw
*/
void WorldNode::DrawTile(float x, float y, float z, float s, CubeSide side, TileType type)
{
D3DXVECTOR3 n; // normal
switch(side)
{
case kTop:
{
D3DXVECTOR3 p1( x, y+s, z );
D3DXVECTOR3 p2( x, y+s, z+s );
D3DXVECTOR3 p3( x+s, y+s, z+s );
D3DXVECTOR3 p4( x+s, y+s, z );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 1.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
case kBottom:
{
D3DXVECTOR3 p1( x, y, z );
D3DXVECTOR3 p2( x, y, z+s );
D3DXVECTOR3 p3( x+s, y, z+s );
D3DXVECTOR3 p4( x+s, y, z );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 1.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
case kLeft:
{
D3DXVECTOR3 p1( x, y, z );
D3DXVECTOR3 p2( x, y, z+s );
D3DXVECTOR3 p3( x, y+s, z+s );
D3DXVECTOR3 p4( x, y+s, z );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(1.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(0.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(1.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
case kRight:
{
D3DXVECTOR3 p1( x+s, y, z );
D3DXVECTOR3 p2( x+s, y+s, z );
D3DXVECTOR3 p3( x+s, y+s, z+s );
D3DXVECTOR3 p4( x+s, y, z+s );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 1.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
case kUpper:
{
D3DXVECTOR3 p1( x, y, z+s );
D3DXVECTOR3 p2( x+s, y, z+s );
D3DXVECTOR3 p3( x+s, y+s, z+s );
D3DXVECTOR3 p4( x, y+s, z+s );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(1.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(0.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(1.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
case kLower:
{
D3DXVECTOR3 p1( x, y, z );
D3DXVECTOR3 p2( x, y+s, z );
D3DXVECTOR3 p3( x+s, y+s, z );
D3DXVECTOR3 p4( x+s, y, z );
D3DXVec3Cross(&n, &(p2-p1), &(p3-p1));
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p2, n, D3DXVECTOR2(0.0f, 0.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
type);
AddPlane(
CustomVertex( p1, n, D3DXVECTOR2(0.0f, 1.0f) ),
CustomVertex( p3, n, D3DXVECTOR2(1.0f, 0.0f) ),
CustomVertex( p4, n, D3DXVECTOR2(1.0f, 1.0f) ),
type);
m_vCollQuads.push_back( CollQuad(p1, p2, p3, p4, n) );
break;
}
default:
break;
}
}
void
run_test(int iterations) {
/*
* Test with Person.
*/
{
Person p1("Jane");
Person p2("John");
Person p3("Mary");
Person p4("Dave");
MAP_T<const Person, int> map;
// Insert people into the map.
auto p1_it = map.insert(std::make_pair(p1, 1));
map.insert(std::make_pair(p2, 2));
map.insert(std::make_pair(p3, 3));
map.insert(std::make_pair(p4, 4));
// Check iterator equality.
{
// Returns an iterator pointing to the first element.
auto it1 = map.begin();
// Returns an iterator pointing to one PAST the last element. This
// iterator is obviously conceptual only. It cannot be
// dereferenced.
auto it2 = map.end();
it1++; // Second node now.
it1++; // Third node now.
it2--; // Fourth node now.
it2--; // Third node now.
assert(it1 == it2);
it2--; // Second node now.
it2--; // First node now.
assert(map.begin() == it2);
}
// Check insert return value.
{
printf("---- Test insert() return.\n");
// Insert returns an interator. If it's already in, it returns an
// iterator to the already inserted element.
auto it = map.insert(std::make_pair(p1, 1));
assert(it == p1_it);
// Now insert one that is new.
it = map.insert(std::make_pair(Person("Larry"), 5));
print(*it);
map.erase(it);
}
// Print the whole thing now, to verify ordering.
printf("---- Before erasures.\n");
// Iterate through the whole map, and call print() on each Person.
for (auto &e : map) {
print(e);
}
// Test multiple traversals of the same map.
printf("---- Multiple traversals\n");
traverse(map, 4);
// Test multiple BST at the same time.
printf("---- Multiple BST\n");
traverse2<MAP_T>(4);
/*
* Test some erasures.
*/
// Erase first element.
map.erase(map.begin());
auto it = map.end();
--it; // it now points to last element.
it--; // it now points to penultimate element.
map.erase(it);
printf("---- After erasures.\n");
// Iterate through the whole map, and call print() on each Person.
for (auto &e : map) {
print(e);
}
// Test iterator validity.
{
// Iterators must be valid even when other things are inserted or
// erased.
printf("---- Test iterator non-invalidation\n");
// Get iterator to the first.
auto b = map.begin();
// Insert element which will be at the end.
auto it = map.insert(std::make_pair(Person("Zeke"), 10));
// Iterator to the first should still be valid.
print(*b);
// Delete first, saving the actual object.
auto tmp(*b); // Save, so we can reinsert.
map.erase(map.begin()); // Erase it.
// Check iterator for inserted. Iterator to end should still be valid.
print(*it); // This should still be valid.
// Reinsert first element.
map.insert(tmp);
// Erase inserted last element.
map.erase(it);
}
}
/*
* Test Map with MyClass.
*/
{
MAP_T<const MyClass, std::string> map;
// Empty container, should print nothing.
for (auto it = map.begin(); it != map.end(); ++it) {
abort();
}
MyClass m1(0), m2(3), m3(1), m4(2);
auto m1_it = map.insert(std::make_pair(m1, "mmm1"));
map.insert(std::make_pair(m2, "mmm2"));
map.insert(std::make_pair(m3, "mmm3"));
map.insert(std::make_pair(m4, "mmm4"));
// Should print 0.0 1.0 2.0 3.0
for (auto &e : map) {
printf("%3.1f ", e.first.num);
}
printf("\n");
// Check return value of insert.
{
// Already in, so must return equal to m1_it.
auto it = map.insert(std::make_pair(m1, "mmm1"));
assert(it == m1_it);
}
// Erase the first element.
map.erase(map.begin());
// Should print "1.0 2.0 3.0".
for (auto &e : map) {
printf("%3.1f ", e.first.num);
}
printf("\n");
// Erase the new first element.
map.erase(map.begin());
// Should print "2.0 3.0".
for (auto &e : map) {
printf("%3.1f ", e.first.num);
}
printf("\n");
map.erase(--map.end());
// Should print "2.0".
for (auto &e : map) {
printf("%3.1f ", e.first.num);
}
printf("\n");
// Erase the last element.
map.erase(map.begin());
// Should print nothing.
for (auto &e : map) {
printf("%3.1f ", e.first.num);
}
printf("\n");
}
/*
* Test Map with plain int.
*/
{
MAP_T<const int, std::string> map;
// Empty container, should print nothing.
for (auto &e : map) {
printf("%d ", e.first);
}
auto p1(std::make_pair(4, "444"));
auto p2(std::make_pair(3, "333"));
auto p3(std::make_pair(0, "000"));
auto p4(std::make_pair(2, "222"));
auto p5(std::make_pair(1, "111"));
map.insert(p1);
map.insert(p2);
map.insert(p3);
map.insert(p4);
map.insert(p5);
// Should print "0 1 2 3 4".
for (auto it = map.begin(); it != map.end(); ++it) {
print(*it);
}
printf("\n");
// Insert dupes.
map.insert(p4);
map.insert(p1);
map.insert(p3);
map.insert(p2);
map.insert(p5);
// Should print "0 1 2 3 4".
for (auto it = map.begin(); it != map.end(); ++it) {
print(*it);
}
printf("\n");
// Erase the first element.
map.erase(map.begin());
// Erase the new first element.
map.erase(map.begin());
// Erase the element in the end.
map.erase(--map.end());
// Should print "2 3".
for (auto &e : map) {
print(e);
}
printf("\n");
// Erase all elements.
map.erase(map.begin());
map.erase(map.begin());
// Should print nothing.
for (auto &e : map) {
print(e);
}
printf("\n");
}
/*
* Stress test Map.
*/
if (iterations > 0) {
MAP_T<const Stress, double> map;
using it_t = typename MAP_T<const Stress, double>::Iterator;
using mirror_t = std::map<const Stress, double>;
mirror_t mirror;
using iters_t = std::set<it_t, bool(*)(const it_t &lhs, const it_t &rhs)>;
iters_t iters(&less<MAP_T>);
std::cout << "---- Starting stress test:" << std::endl;
const int N = iterations;
srand(9757);
int n_inserted = 0, n_erased = 0, n_iters_changed = 0, n_empty = 0, n_dupes = 0;
double avg_size = 0;
for (int i = 0; i < N; ++i) {
double op = drand48();
// The probability of removal should be slightly higher than the
// probability of insertion so that the map is often empty.
if (op < .44) {
// Insert an element. Repeat until no duplicate.
do {
// Limit the range of values of Stress so that we get some dupes.
auto v(std::make_pair(Stress(rand()%50000), drand48()));
auto find_it = map.find(v.first);
auto it = map.insert(v);
auto mir_res = mirror.insert(v);
if (mir_res.second) {
// If insert into mirror succeeded, insert into the map
// should also have succeeded. It should not have
// found it before insert.
assert(find_it == map.end());
// Store the iterator.
iters.insert(it);
break;
}
// If insert into mirror did not succeed, insert into map
// should also not have succeeded, in which case, we
// generate another value to store. Also, find should have
// found it, and insert should have returned same iterator.
assert(find_it == it);
n_dupes++;
} while (true);
++n_inserted;
} else if (op < .90) {
// Erase an element.
if (iters.size() != 0) {
// Pick a random index.
int index = rand()%iters.size();
typename iters_t::iterator iit = iters.begin();
while(index--) {
++iit;
}
auto it = *iit;
// The iterator should not be end()
assert(it != map.end());
Stress s((*it).first);
mirror.erase(s);
iters.erase(iit);
map.erase(it);
++n_erased;
}
} else {
// Does either postfix or prefix inc/dec operation.
auto either_or = [&](it_t &it, it_t &(it_t::*f1)(), it_t (it_t::*f2)(int)) {
if (rand()%2 == 0) {
(it.*f1)();
} else {
(it.*f2)(0);
}
};
// Increment or decrement an iterator.
// Size of containers should be same
assert(iters.size() == mirror.size());
// If the container is empty, skip
if (iters.size() != 0) {
// Pick a random index
int index = rand()%iters.size();
typename iters_t::iterator iters_it = iters.begin();
while (index--) {
++iters_it;
}
auto it = *iters_it;
// The iterator should not be end().
assert(it != map.end());
// If it is the begin(), then only increment,
// otherwise, pick either forward or backward.
if (it == map.begin()) {
either_or(it, &it_t::operator++, &it_t::operator++);
++iters_it;
} else {
if (rand()%2 == 0) {
either_or(it, &it_t::operator++, &it_t::operator++);
++iters_it;
} else {
either_or(it, &it_t::operator--, &it_t::operator--);
--iters_it;
}
}
// If we didn't hit the end, replace the resulting iterator
// in the iterator list.
// Note that the set is sorted.
if (it != map.end()) {
assert(it == *iters_it);
iters.erase(iters_it);
iters.insert(it);
}
}
++n_iters_changed;
}
avg_size += double(iters.size())/N;
if (iters.size() == 0) {
++n_empty;
}
check(map, mirror);
}
std::cout << "inserted: " << n_inserted << " times" << std::endl;
std::cout << "erased: " << n_erased << " times" << std::endl;
std::cout << "iterators changed: " << n_iters_changed << " times" << std::endl;
std::cout << "empty count: " << n_empty << std::endl;
std::cout << "avg size: " << avg_size << std::endl;
std::cout << "n dupes: " << n_dupes << std::endl;
}
}
void Slur::computeBezier(SlurSegment* ss, QPointF p6o)
{
qreal _spatium = spatium();
qreal shoulderW; // height as fraction of slur-length
qreal shoulderH;
//
// p1 and p2 are the end points of the slur
//
QPointF pp1 = ss->ups[GRIP_START].p + ss->ups[GRIP_START].off * _spatium;
QPointF pp2 = ss->ups[GRIP_END].p + ss->ups[GRIP_END].off * _spatium;
QPointF p2 = pp2 - pp1;
if ((p2.x() == 0.0) && (p2.y() == 0.0)) {
qDebug("zero slur");
abort();
Measure* m1 = startChord()->segment()->measure();
Measure* m2 = endChord()->segment()->measure();
Page* page = m1->system()->page();
qDebug(" at tick %d in measure %d-%d page %d",
m1->tick(), m1->no(), m2->no(), page->no());
return;
}
qreal sinb = atan(p2.y() / p2.x());
QTransform t;
t.rotateRadians(-sinb);
p2 = t.map(p2);
p6o = t.map(p6o);
double smallH = 0.5;
qreal d = p2.x() / _spatium;
if (d <= 2.0) {
shoulderH = d * 0.5 * smallH * _spatium;
shoulderW = .6;
}
else {
qreal dd = log10(1.0 + (d - 2.0) * .5) * 2.0;
if (dd > 3.0)
dd = 3.0;
shoulderH = (dd + smallH) * _spatium;
if (d > 18.0)
shoulderW = 0.7; // 0.8;
else if (d > 10)
shoulderW = 0.6; // 0.7;
else
shoulderW = 0.5; // 0.6;
}
shoulderH -= p6o.y();
if (!up())
shoulderH = -shoulderH;
qreal c = p2.x();
qreal c1 = (c - c * shoulderW) * .5 + p6o.x();
qreal c2 = c1 + c * shoulderW + p6o.x();
QPointF p5 = QPointF(c * .5, 0.0);
QPointF p3(c1, -shoulderH);
QPointF p4(c2, -shoulderH);
qreal w = (score()->styleS(ST_SlurMidWidth).val() - score()->styleS(ST_SlurEndWidth).val()) * _spatium;
if (((c2 - c1) / _spatium) <= _spatium)
w *= .5;
QPointF th(0.0, w); // thickness of slur
QPointF p3o = p6o + t.map(ss->ups[GRIP_BEZIER1].off * _spatium);
QPointF p4o = p6o + t.map(ss->ups[GRIP_BEZIER2].off * _spatium);
if(!p6o.isNull()) {
QPointF p6i = t.inverted().map(p6o) / _spatium;
ss->ups[GRIP_BEZIER1].off += p6i ;
ss->ups[GRIP_BEZIER2].off += p6i;
}
//-----------------------------------calculate p6
QPointF pp3 = p3 + p3o;
QPointF pp4 = p4 + p4o;
QPointF ppp4 = pp4 - pp3;
qreal r2 = atan(ppp4.y() / ppp4.x());
t.reset();
t.rotateRadians(-r2);
QPointF p6 = QPointF(t.map(ppp4).x() * .5, 0.0);
t.rotateRadians(2 * r2);
p6 = t.map(p6) + pp3 - p6o;
//-----------------------------------
ss->path = QPainterPath();
ss->path.moveTo(QPointF());
ss->path.cubicTo(p3 + p3o - th, p4 + p4o - th, p2);
if (lineType() == 0)
ss->path.cubicTo(p4 +p4o + th, p3 + p3o + th, QPointF());
th = QPointF(0.0, 3.0 * w);
ss->shapePath = QPainterPath();
ss->shapePath.moveTo(QPointF());
ss->shapePath.cubicTo(p3 + p3o - th, p4 + p4o - th, p2);
ss->shapePath.cubicTo(p4 +p4o + th, p3 + p3o + th, QPointF());
// translate back
t.reset();
t.translate(pp1.x(), pp1.y());
t.rotateRadians(sinb);
ss->path = t.map(ss->path);
ss->shapePath = t.map(ss->shapePath);
ss->ups[GRIP_BEZIER1].p = t.map(p3);
ss->ups[GRIP_BEZIER2].p = t.map(p4);
ss->ups[GRIP_END].p = t.map(p2) - ss->ups[GRIP_END].off * _spatium;
ss->ups[GRIP_DRAG].p = t.map(p5);
ss->ups[GRIP_SHOULDER].p = t.map(p6);
}
int main( int argc, char* argv[]) {
// create some points in the plane
Point p1(1,2), p2(4,2);
Point p3(2,1), p4(4,3);
Point p5(2,2), p6(6,2);
Point p7(1,4), p8(2,3);
Point p9(3,2), p10(5,0);
// create some segments
Segment s1(p1, p2);
Segment s2(p3, p4);
Segment s3(p5, p6);
Segment s4(p7, p8);
Segment s5(p9, p10);
// test with predicate functions
echo("*****************************************************************");
echo("Segment 1 and 2, they should intersect at point (3,2)");
printSegments(s1, s2);
testForIntersectionAndPrint(s1, s2);
doIntersectionAndPrint(s1, s2);
newline();
echo("Segment 1 and 3, they should intersect at segment (2,2), (4,2)");
printSegments(s1, s3);
testForIntersectionAndPrint(s1, s3);
doIntersectionAndPrint(s1, s3);
newline();
echo("Segment 1 and 4, they should not intersect");
printSegments(s1, s4);
testForIntersectionAndPrint(s1, s4);
doIntersectionAndPrint(s1, s4);
newline();
echo("Segment 2 and 5, they should intersect at point (3,2)");
printSegments(s2, s5);
testForIntersectionAndPrint(s2, s5);
doIntersectionAndPrint(s2, s5);
newline();
echo("Segment 2 and 2, they should intersect at segment (2,1), (4,3)");
printSegments(s2, s2);
testForIntersectionAndPrint(s2, s2);
doIntersectionAndPrint(s2, s2);
newline();
// test with non-predicate functions
echo("*****************************************************************");
echo("Segment 1 and 2, they should intersect at point (3,2)");
printSegments(s1, s2);
testForIntersectionAndPrint2(s1, s2);
doIntersectionAndPrint2(s1, s2);
newline();
echo("Segment 1 and 3, they should intersect at segment (2,2), (4,2)");
printSegments(s1, s3);
testForIntersectionAndPrint2(s1, s3);
doIntersectionAndPrint2(s1, s3);
newline();
echo("Segment 1 and 4, they should not intersect");
printSegments(s1, s4);
testForIntersectionAndPrint2(s1, s4);
doIntersectionAndPrint2(s1, s4);
newline();
echo("Segment 2 and 5, they should intersect at point (3,2)");
printSegments(s2, s5);
testForIntersectionAndPrint2(s2, s5);
doIntersectionAndPrint2(s2, s5);
newline();
echo("Segment 2 and 2, they should intersect at segment (2,1), (4,3)");
printSegments(s2, s2);
testForIntersectionAndPrint2(s2, s2);
doIntersectionAndPrint2(s2, s2);
newline();
return 0;
}
void InversionContrib::getGrad(double *pos, double *grad) const {
PRECONDITION(dp_forceField, "no owner");
PRECONDITION(pos, "bad vector");
PRECONDITION(grad, "bad vector");
RDGeom::Point3D p1(pos[3 * d_at1Idx],
pos[3 * d_at1Idx + 1],
pos[3 * d_at1Idx + 2]);
RDGeom::Point3D p2(pos[3 * d_at2Idx],
pos[3 * d_at2Idx + 1],
pos[3 * d_at2Idx + 2]);
RDGeom::Point3D p3(pos[3 * d_at3Idx],
pos[3 * d_at3Idx + 1],
pos[3 * d_at3Idx + 2]);
RDGeom::Point3D p4(pos[3 * d_at4Idx],
pos[3 * d_at4Idx + 1],
pos[3 * d_at4Idx + 2]);
double *g1 = &(grad[3 * d_at1Idx]);
double *g2 = &(grad[3 * d_at2Idx]);
double *g3 = &(grad[3 * d_at3Idx]);
double *g4 = &(grad[3 * d_at4Idx]);
RDGeom::Point3D rJI = p1 - p2;
RDGeom::Point3D rJK = p3 - p2;
RDGeom::Point3D rJL = p4 - p2;
double dJI = rJI.length();
double dJK = rJK.length();
double dJL = rJL.length();
if (isDoubleZero(dJI) || isDoubleZero(dJK) || isDoubleZero(dJL)) {
return;
}
rJI /= dJI;
rJK /= dJK;
rJL /= dJL;
RDGeom::Point3D n = (-rJI).crossProduct(rJK);
n /= n.length();
double cosY = n.dotProduct(rJL);
clipToOne(cosY);
double sinYSq = 1.0 - cosY * cosY;
double sinY = std::max(((sinYSq > 0.0) ? sqrt(sinYSq) : 0.0), 1.0e-8);
double cosTheta = rJI.dotProduct(rJK);
clipToOne(cosTheta);
double sinThetaSq = std::max(1.0 - cosTheta * cosTheta, 1.0e-8);
double sinTheta = std::max(((sinThetaSq > 0.0) ? sqrt(sinThetaSq) : 0.0), 1.0e-8);
// sin(2 * W) = 2 * sin(W) * cos(W) = 2 * cos(Y) * sin(Y)
double dE_dW = -d_forceConstant
* (d_C1 * cosY - 4.0 * d_C2 * cosY * sinY);
RDGeom::Point3D t1 = rJL.crossProduct(rJK);
RDGeom::Point3D t2 = rJI.crossProduct(rJL);
RDGeom::Point3D t3 = rJK.crossProduct(rJI);
double term1 = sinY * sinTheta;
double term2 = cosY / (sinY * sinThetaSq);
double tg1[3] = { (t1.x / term1 - (rJI.x - rJK.x * cosTheta) * term2) / dJI,
(t1.y / term1 - (rJI.y - rJK.y * cosTheta) * term2) / dJI,
(t1.z / term1 - (rJI.z - rJK.z * cosTheta) * term2) / dJI };
double tg3[3] = { (t2.x / term1 - (rJK.x - rJI.x * cosTheta) * term2) / dJK,
(t2.y / term1 - (rJK.y - rJI.y * cosTheta) * term2) / dJK,
(t2.z / term1 - (rJK.z - rJI.z * cosTheta) * term2) / dJK };
double tg4[3] = { (t3.x / term1 - rJL.x * cosY / sinY) / dJL,
(t3.y / term1 - rJL.y * cosY / sinY) / dJL,
(t3.z / term1 - rJL.z * cosY / sinY) / dJL };
for (unsigned int i = 0; i < 3; ++i) {
g1[i] += dE_dW * tg1[i];
g2[i] += -dE_dW * (tg1[i] + tg3[i] + tg4[i]);
g3[i] += dE_dW * tg3[i];
g4[i] += dE_dW * tg4[i];
}
}
void init_mine_mesh(GLShape& base_mesh, GLShape& wheel_mesh) {
float d = 0.025f;
float x0 = 1.5f * d;
float x1 = 2.0f * d;
float y0 = 3.0f * d;
float y1 = 4.0f * d;
float z0 = d * 0.25f;
float z1 = d;
Vector3 p0(-x1, 0.0f, z1);
Vector3 p1(-x0, 0.0f, z1);
Vector3 p2(-x0, y0, z0);
Vector3 p3(x0, y0, z0);
Vector3 p4(x0, 0.0f, z1);
Vector3 p5(x1, 0.0f, z1);
Vector3 p6(x1, y1, 0.0f);
Vector3 p7(-x1, y1, 0.0f);
Vector3 q0(-x1, 0.0f, -z1);
Vector3 q1(-x0, 0.0f, -z1);
Vector3 q2(-x0, y0, -z0);
Vector3 q3(x0, y0, -z0);
Vector3 q4(x0, 0.0f, -z1);
Vector3 q5(x1, 0.0f, -z1);
Vector3 q6(x1, y1, 0.0f);
Vector3 q7(-x1, y1, 0.0f);
base_mesh = {
p0, p1, p2, p0, p2, p7, p2, p3, p6, p2, p6, p7, p3, p4, p5, p3, p5, p6,
q0, q1, q2, q0, q2, q7, q2, q3, q6, q2, q6, q7, q3, q4, q5, q3, q5, q6
};
std::vector<Vector2> wheel = circle(Vector2(), 3.0f * d, 16);
wheel = cut(wheel, circle(Vector2(), 2.5f * d, 16));
wheel_mesh = to_xy(triangulate(wheel));
Vector3 w0(-d * 0.25f, -2.75f * d, 0.0f);
Vector3 w1(d * 0.25f, -2.75f * d, 0.0f);
Vector3 w2(d * 0.25f, 2.75f * d, 0.0f);
Vector3 w3(-d * 0.25f, 2.75f * d, 0.0f);
Vector3 w4(-d * 2.75f, -0.25f * d, 0.0f);
Vector3 w5(d * 2.75f, -0.25f * d, 0.0f);
Vector3 w6(d * 2.75f, 0.25f * d, 0.0f);
Vector3 w7(-d * 2.75f, 0.25f * d, 0.0f);
wheel_mesh.push_back(w0);
wheel_mesh.push_back(w1);
wheel_mesh.push_back(w2);
wheel_mesh.push_back(w0);
wheel_mesh.push_back(w2);
wheel_mesh.push_back(w3);
wheel_mesh.push_back(w4);
wheel_mesh.push_back(w5);
wheel_mesh.push_back(w6);
wheel_mesh.push_back(w4);
wheel_mesh.push_back(w6);
wheel_mesh.push_back(w7);
}
void BuildTreeDoubleYShape(Node *node[], Tree &tree)
{
const KDL::Vector unitx(1,0,0);
const KDL::Vector unity(0,1,0);
const KDL::Vector unitz(0,0,1);
const KDL::Vector unit1(sqrt(14.0)/8.0, 1.0/8.0, 7.0/8.0);
const KDL::Vector zero = KDL::Vector::Zero();
KDL::Vector p0(0.0f, -1.5f, 0.0f);
KDL::Vector p1(0.0f, -1.0f, 0.0f);
KDL::Vector p2(0.0f, -0.5f, 0.0f);
KDL::Vector p3(0.5f*Root2Inv, -0.5+0.5*Root2Inv, 0.0f);
KDL::Vector p4(0.5f*Root2Inv+0.5f*HalfRoot3, -0.5+0.5*Root2Inv+0.5f*0.5, 0.0f);
KDL::Vector p5(0.5f*Root2Inv+1.0f*HalfRoot3, -0.5+0.5*Root2Inv+1.0f*0.5, 0.0f);
KDL::Vector p6(0.5f*Root2Inv+1.5f*HalfRoot3, -0.5+0.5*Root2Inv+1.5f*0.5, 0.0f);
KDL::Vector p7(0.5f*Root2Inv+0.5f*HalfRoot3, -0.5+0.5*Root2Inv+0.5f*HalfRoot3, 0.0f);
KDL::Vector p8(0.5f*Root2Inv+1.0f*HalfRoot3, -0.5+0.5*Root2Inv+1.0f*HalfRoot3, 0.0f);
KDL::Vector p9(0.5f*Root2Inv+1.5f*HalfRoot3, -0.5+0.5*Root2Inv+1.5f*HalfRoot3, 0.0f);
KDL::Vector p10(-0.5f*Root2Inv, -0.5+0.5*Root2Inv, 0.0f);
KDL::Vector p11(-0.5f*Root2Inv-0.5f*HalfRoot3, -0.5+0.5*Root2Inv+0.5f*HalfRoot3, 0.0f);
KDL::Vector p12(-0.5f*Root2Inv-1.0f*HalfRoot3, -0.5+0.5*Root2Inv+1.0f*HalfRoot3, 0.0f);
KDL::Vector p13(-0.5f*Root2Inv-1.5f*HalfRoot3, -0.5+0.5*Root2Inv+1.5f*HalfRoot3, 0.0f);
KDL::Vector p14(-0.5f*Root2Inv-0.5f*HalfRoot3, -0.5+0.5*Root2Inv+0.5f*0.5, 0.0f);
KDL::Vector p15(-0.5f*Root2Inv-1.0f*HalfRoot3, -0.5+0.5*Root2Inv+1.0f*0.5, 0.0f);
KDL::Vector p16(-0.5f*Root2Inv-1.5f*HalfRoot3, -0.5+0.5*Root2Inv+1.5f*0.5, 0.0f);
node[0] = new Node(p0, unit1, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertRoot(node[0]);
node[1] = new Node(p1, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[0], node[1]);
node[2] = new Node(p1, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[1], node[2]);
node[3] = new Node(p2, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[2], node[3]);
node[4] = new Node(p2, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertRightSibling(node[3], node[4]);
node[5] = new Node(p3, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[3], node[5]);
node[6] = new Node(p3, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertRightSibling(node[5], node[6]);
node[7] = new Node(p3, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[5], node[7]);
node[8] = new Node(p4, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[7], node[8]);
node[9] = new Node(p5, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[8], node[9]);
node[10] = new Node(p5, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[9], node[10]);
node[11] = new Node(p6, zero, 0.08, EFFECTOR);
tree.InsertLeftChild(node[10], node[11]);
node[12] = new Node(p3, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[6], node[12]);
node[13] = new Node(p7, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[12], node[13]);
node[14] = new Node(p8, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[13], node[14]);
node[15] = new Node(p8, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[14], node[15]);
node[16] = new Node(p9, zero, 0.08, EFFECTOR);
tree.InsertLeftChild(node[15], node[16]);
node[17] = new Node(p10, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[4], node[17]);
node[18] = new Node(p10, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[17], node[18]);
node[19] = new Node(p10, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertRightSibling(node[17], node[19]);
node[20] = new Node(p11, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[18], node[20]);
node[21] = new Node(p12, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[20], node[21]);
node[22] = new Node(p12, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[21], node[22]);
node[23] = new Node(p13, zero, 0.08, EFFECTOR);
tree.InsertLeftChild(node[22], node[23]);
node[24] = new Node(p10, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[19], node[24]);
node[25] = new Node(p14, unitz, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[24], node[25]);
node[26] = new Node(p15, unitx, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[25], node[26]);
node[27] = new Node(p15, unity, 0.08, JOINT, RADIAN(-180.), RADIAN(180.), RADIAN(30.));
tree.InsertLeftChild(node[26], node[27]);
node[28] = new Node(p16, zero, 0.08, EFFECTOR);
tree.InsertLeftChild(node[27], node[28]);
}
int testPlane() {
int numErr = 0;
logMessage(_T("TESTING - class GM_3dPlane ...\n\n"));
// Default constructor, plane must be invalid
GM_3dPlane p;
if (p.isValid()) {
logMessage(_T("\tERROR - Default constructor creates valid plane\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Default constructor creates invalid plane\n"));
}
// Constructor (coeff)
GM_3dPlane p1(getRandomDouble(), getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPlane pNull(0.0, 0.0, 0.0, getRandomDouble());
if (!p1.isValid() || pNull.isValid()) {
logMessage(_T("\tERROR - Coeff. constructor not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Coeff. constructor working\n"));
}
// Copy constructor
GM_3dPlane copyPlane(p1);
if (!copyPlane.isValid() || copyPlane != p1) {
logMessage(_T("\tERROR - Copy constructor not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Copy constructor working\n"));
}
// Constructor (coeff vector)
double pointsVect[4];
for (int i = 0 ; i < 4 ; i++) {
pointsVect[i] = getRandomDouble();
}
GM_3dPlane p2(pointsVect);
if (!p2.isValid()) {
logMessage(_T("\tERROR - Coeff. vector constructor not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Coeff. vector constructor working\n"));
}
// Constructor (points)
GM_3dPoint pt1(getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPoint pt2(getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPoint pt3(getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dLine ln(getRandomDouble(), getRandomDouble(), getRandomDouble(),getRandomDouble(), getRandomDouble(), getRandomDouble());
GM_3dPoint ptLn1 = ln.begin();
GM_3dPoint ptLn2 = ln.center();
GM_3dPoint ptLn3 = ln.end();
GM_3dPlane p3(pt1, pt2, pt3);
GM_3dPlane pLine(ptLn2, ptLn2, ptLn3);
double distPt1 = pt1.x()*p3[0] + pt1.y()*p3[1] + pt1.z()*p3[2] + p3[3];
double distPt2 = pt2.x()*p3[0] + pt2.y()*p3[1] + pt2.z()*p3[2] + p3[3];
double distPt3 = pt3.x()*p3[0] + pt3.y()*p3[1] + pt3.z()*p3[2] + p3[3];
if (!p3.isValid() || pLine.isValid() || fabs(distPt1) > GM_NULL_TOLERANCE || fabs(distPt2) > GM_NULL_TOLERANCE || fabs(distPt3) > GM_NULL_TOLERANCE) {
logMessage(_T("\tERROR - Points constructor not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Points constructor working\n"));
}
// Point distance
GM_3dPlane p4(getRandomDouble(), getRandomDouble(), getRandomDouble(),getRandomDouble());
GM_3dPoint checkPoint(getRandomDouble(), getRandomDouble(), getRandomDouble());
if (fabs(p4[0]) > GM_NULL_TOLERANCE) {
checkPoint.x(-(checkPoint.y()*p4[1] + checkPoint.z()*p4[2] + p4[3]) / p4[0]);
}
else if (fabs(p4[1]) > GM_NULL_TOLERANCE) {
checkPoint.y(-(checkPoint.x()*p4[0] + checkPoint.z()*p4[2] + p4[3]) / p4[1]);
}
else if (fabs(p4[2]) > GM_NULL_TOLERANCE) {
checkPoint.z(-(checkPoint.x()*p4[0] + checkPoint.y()*p4[1] + p4[3]) / p4[2]);
}
else {
p4.invalidate();
}
double checkSignedDist = getRandomDouble();
double checkDist = fabs(checkSignedDist);
GM_3dVector p4Norm = p4.normalVector();
checkPoint = (GM_3dVector)checkPoint + (p4Norm * checkSignedDist);
GM_3dPoint checkPointOnPlane1;
GM_3dPoint checkPointOnPlane2;
double dist = p4.pointDistance(checkPoint);
double signedDist = p4.pointDistanceSgn(checkPoint);
double signedDistOnPlane = p4.pointDistanceSgn(checkPoint, checkPointOnPlane1);
double distOnPlane = p4.pointDistance(checkPoint, checkPointOnPlane2);
distPt1 = checkPointOnPlane1.x()*p4[0] + checkPointOnPlane1.y()*p4[1] + checkPointOnPlane1.z()*p4[2] + p4[3];
distPt2 = checkPointOnPlane2.x()*p4[0] + checkPointOnPlane2.y()*p4[1] + checkPointOnPlane2.z()*p4[2] + p4[3];
if (!p4.isValid() || !checkPointOnPlane1.isValid() || !checkPointOnPlane2.isValid() ||
fabs(distPt1) > GM_NULL_TOLERANCE || fabs(distPt2) > GM_NULL_TOLERANCE ||
fabs(distOnPlane - checkDist) > GM_NULL_TOLERANCE || fabs(signedDistOnPlane - checkSignedDist) > GM_NULL_TOLERANCE ||
fabs(dist - checkDist) > GM_NULL_TOLERANCE || fabs(signedDist - checkSignedDist) > GM_NULL_TOLERANCE) {
logMessage(_T("\tERROR - Point distance computation not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - Point distance computation working\n"));
}
// XY Angle
double angle = ((((double)rand()) / ((double)RAND_MAX)) * GM_PI) - (GM_PI / 2.0);
GM_3dVector normVector(angle/* + GM_HALFPI*/);
normVector.z(normVector.y());
normVector.y(0.0);
GM_3dPlane angleP(normVector, GM_3dPoint(getRandomDouble(), getRandomDouble(), getRandomDouble()));
double checkAngle = angleP.xyAngle();
if (checkAngle > GM_PI) {
checkAngle -= 2.0 * GM_PI;
}
if (!angleP.isValid() || fabs(angle - checkAngle) > GM_NULL_TOLERANCE) {
logMessage(_T("\tERROR - XY angle computation not working\n"));
numErr++;
}
else {
logMessage(_T("\tOK - XY angle computation working\n"));
}
return numErr;
}
void testController(){
MemRepository* repo=new MemRepository();
Controller c(repo);
string errors="";
Expense p(1, 21, 92, "clothing");
c.add(p);
assert(c.size()==1);
Expense p1(2, 23, 440, "telephone");
c.add(p1);
assert(c.size()==2);
Expense p2(3, 2, 9, "pizza");
try{
c.add(p2);
}
catch(RepositoryException& s)
{
errors+=s.getMsg();
}
assert(c.size()==2);
assert(errors!="");
errors="";
Expense p3(3, 34, 29, "others");
try{
c.add(p2);
}
catch(RepositoryException& s)
{
errors+=s.getMsg();
}
assert(c.size()==2);
assert(errors!="");
Expense p4(1, 23, 440, "others");
c.update(1,p4);
vector<Expense*> all=c.getAll();
assert(all.at(0)->getDay()==23);
assert(c.size()==2);
errors="";
try{
c.update(1,p3);
}
catch (RepositoryException& s1)
{
errors+=s1.getMsg();
}
assert(errors!="");
c.remove(1);
assert (c.size()==1);
errors="";
try{
c.remove(7);
}
catch (RepositoryException& s1)
{
errors+=s1.getMsg();
}
assert(errors!="");
assert (c.size()==1);
c.add(p);
all=c.filterByDay(23);
assert(all.size()==1);
all=c.filterByAmount(440);
assert(all.size()==1);
all=c.sortByAmountA();
assert(all.at(0)->getId()==1);
all=c.sortByAmountD();
assert(all.at(0)->getId()==2);
all=c.sortByTypeA();
assert(all.at(0)->getId()==1);
all=c.sortByTypeD();
assert(all.at(0)->getId()==2);
}
void TorsionConstraintContrib::getGrad(double *pos, double *grad) const
{
PRECONDITION(dp_forceField,"no owner");
PRECONDITION(pos,"bad vector");
PRECONDITION(grad,"bad vector");
RDGeom::Point3D p1(pos[3 * d_at1Idx],
pos[3 * d_at1Idx + 1], pos[3 * d_at1Idx + 2]);
RDGeom::Point3D p2(pos[3 * d_at2Idx],
pos[3 * d_at2Idx + 1], pos[3 * d_at2Idx + 2]);
RDGeom::Point3D p3(pos[3 * d_at3Idx],
pos[3 * d_at3Idx + 1], pos[3 * d_at3Idx + 2]);
RDGeom::Point3D p4(pos[3 * d_at4Idx],
pos[3 * d_at4Idx + 1], pos[3 * d_at4Idx + 2]);
double *g[4] = {
&(grad[3 * d_at1Idx]),
&(grad[3 * d_at2Idx]),
&(grad[3 * d_at3Idx]),
&(grad[3 * d_at4Idx])
};
RDGeom::Point3D r[4] = {
p1 - p2,
p3 - p2,
p2 - p3,
p4 - p3
};
RDGeom::Point3D t[2] = {
r[0].crossProduct(r[1]),
r[2].crossProduct(r[3])
};
double d[2] = {
t[0].length(),
t[1].length()
};
if (isDoubleZero(d[0]) || isDoubleZero(d[1])) {
return;
}
t[0] /= d[0];
t[1] /= d[1];
double cosPhi = t[0].dotProduct(t[1]);
double sinPhiSq = 1.0 - cosPhi * cosPhi;
double sinPhi = ((sinPhiSq > 0.0) ? sqrt(sinPhiSq) : 0.0);
// dE/dPhi is independent of cartesians:
RDGeom::Point3D n123 = (-r[0]).crossProduct(r[1]);
double n123SqLength = n123.lengthSq();
RDGeom::Point3D n234 = r[1].crossProduct(r[3]);
double n234SqLength = n234.lengthSq();
RDGeom::Point3D m = n123.crossProduct(r[1]);
// we want a signed dihedral, that's why we use atan2 instead of acos
double dihedral = RAD2DEG * (-atan2(m.dotProduct(n234) / sqrt(n234SqLength * m.lengthSq()),
n123.dotProduct(n234) / sqrt(n123SqLength * n234SqLength)));
//double dihedral = RAD2DEG * acos(cosPhi);
double ave = 0.5 * (d_minDihedralDeg + d_maxDihedralDeg);
dihedral += 360.0 * boost::math::round((ave - dihedral) / 360.0);
double dihedralTerm = 0.0;
if (dihedral < d_minDihedralDeg) {
dihedralTerm = dihedral - d_minDihedralDeg;
}
else if (dihedral > d_maxDihedralDeg) {
dihedralTerm = dihedral - d_maxDihedralDeg;
}
double dE_dPhi = DEG2RAD * d_forceConstant * dihedralTerm;
// FIX: use a tolerance here
// this is hacky, but it's per the
// recommendation from Niketic and Rasmussen:
double sinTerm = -dE_dPhi * (isDoubleZero(sinPhi)
? (1.0 / cosPhi) : (1.0 / sinPhi));
Utils::calcTorsionGrad(r, t, d, g, sinTerm, cosPhi);
}
int main(int argc, char* argv[])
{
CS325Graphics window(argc, argv);
float delta = 0.1;
Point2D p1(CS325Graphics::X_MIN, CS325Graphics::Y_MAX / 4.5);
Point2D p2(CS325Graphics::X_MAX, CS325Graphics::Y_MAX / 4.5);
Point2D p3(CS325Graphics::X_MIN, CS325Graphics::Y_MIN);
Point2D p4(CS325Graphics::X_MAX, CS325Graphics::Y_MAX);
//Points 41, 42, 45, 46 control the sandbox. DON"T MESS WITH THEM!
Point3D p30(0.5, 0.5,-3.5);
Point3D p31(0.5, -0.5,-3.5);
Point3D p32(-0.5,-0.5,-3.5);
Point3D p33(-0.5, 0.5,-3.5);
Point3D p34(0.5, 0.5,-1.5);
Point3D p35(0.5, -0.5,-1.5);
Point3D p36(-0.5,-0.5,-1.5);
Point3D p37(-0.5, 0.5,-1.5);
Point3D p40( -70.8, 28.8, -50.8);
Point3D p41( 50.8,-2.8, 50.8);
Point3D p42(-50.8,-2.8, 50.8);
Point3D p43(-58.8, 25.8, 50.8);
Point3D p44( 50.8, 50.8, -50.8);
Point3D p45( 50.8,-2.8, -50.8);
Point3D p46(-50.8,-2.8, -50.8);
Point3D p47(-84.8,-2.8, -50.8);
Point3D p49(-8.5,22.0, 50.8);
Point3D p48(70,20,50.8);
Point3D p50(3.5, 0.5,-3.5);
Point3D p51(3.5, -0.5,-3.5);
Point3D p52(2.5,-0.5,-3.5);
Point3D p53(2.5, 0.5,-3.5);
Point3D p54(3.5, 0.5,-1.5);
Point3D p55(3.5, -0.5,-1.5);
Point3D p56(2.5,-0.5,-1.5);
Point3D p57(2.5, 0.5,-1.5);
Point3D p60(3.5, 0.5, 13.5);
Point3D p61(3.5, -0.5, 13.5);
Point3D p62(2.5,-0.5, 13.5);
Point3D p63(2.5, 0.5, 13.5);
Point3D p64(3.5, 0.5, 16.5);
Point3D p65(3.5, -0.5, 16.5);
Point3D p66(2.5,-0.5, 16.5);
Point3D p67(2.5, 0.5, 16.5);
Point2D viewPos;
Vector2D viewDir;
Vector3D deltaV;
viewDir.setAngle(0);
// move view position
for(int i = 0; i < MOVE_TEST; i){
/*window.DrawLineOnScreen(p1, p2);*/
//window.DrawLineOnScreen(p4, p3);
window.DrawLineInSpace(p30, p31);
window.DrawLineInSpace(p31, p32);
window.DrawLineInSpace(p32, p33);
window.DrawLineInSpace(p33, p30);
window.DrawLineInSpace(p34, p35);
window.DrawLineInSpace(p35, p36);
window.DrawLineInSpace(p36, p37);
window.DrawLineInSpace(p37, p34);
window.DrawLineInSpace(p30, p34);
window.DrawLineInSpace(p31, p35);
window.DrawLineInSpace(p32, p36);
window.DrawLineInSpace(p33, p37);
window.DrawLineInSpace(p50, p51);
window.DrawLineInSpace(p51, p52);
window.DrawLineInSpace(p52, p53);
window.DrawLineInSpace(p53, p50);
window.DrawLineInSpace(p54, p55);
window.DrawLineInSpace(p55, p56);
window.DrawLineInSpace(p56, p57);
window.DrawLineInSpace(p57, p54);
window.DrawLineInSpace(p50, p54);
window.DrawLineInSpace(p51, p55);
window.DrawLineInSpace(p52, p56);
window.DrawLineInSpace(p53, p57);
window.DrawLineInSpace(p60, p61);
window.DrawLineInSpace(p61, p62);
window.DrawLineInSpace(p62, p63);
window.DrawLineInSpace(p63, p60);
window.DrawLineInSpace(p64, p65);
window.DrawLineInSpace(p65, p66);
window.DrawLineInSpace(p66, p67);
window.DrawLineInSpace(p67, p64);
window.DrawLineInSpace(p60, p64);
window.DrawLineInSpace(p61, p65);
window.DrawLineInSpace(p62, p66);
window.DrawLineInSpace(p63, p67);
//window.DrawLineInSpace(p40, p41);
window.DrawLineInSpace(p41, p42);
window.DrawLineInSpace(p42, p43);
//window.DrawLineInSpace(p43, p40);
//window.DrawLineInSpace(p44, p45);
window.DrawLineInSpace(p45, p46);
//window.DrawLineInSpace(p46, p47);
//window.DrawLineInSpace(p47, p44);
window.DrawLineInSpace(p40, p45);
window.DrawLineInSpace(p41, p45);
window.DrawLineInSpace(p42, p46);
window.DrawLineInSpace(p43, p47);
window.DrawLineInSpace(p40, p47);
window.DrawLineInSpace(p41, p49);
window.DrawLineInSpace(p42, p49);
window.DrawLineInSpace(p41, p48);
window.DrawLineInSpace(p45, p48);
if(GetAsyncKeyState(VK_DOWN)) // the DOWN arrow was pressed, let's do something
{
delta = -.1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_UP)) // the UP arrow was pressed, let's do something
{
delta = .1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_RIGHT)) // the RIGHT arrow was pressed, let's do something
{
delta = .1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_LEFT)) // the LEFT arrow was pressed, let's do something
{
delta = -.1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_ESCAPE))
{
return 1;
}
}
}
QPointF transition::getP1(){
// = point de départ de la flèche
QPointF retPoint;
if(!nodesAreCircles){
/*-------------------------------
* Pour des noeud rectangulaires
*------------------------------*/
/*
(p1) T (p2)
+----------------+
| |
L | Noeud | R
| |
+----------------+
(p4) B (p3)
* EQ(1) * EQ(2)
* *
* *
* *
*
* *
* *
* *
*/
QPointF T(n1->getX()+(n1->getWidth()/2),n1->getY()); //centre du T du noeud1
QPointF R(n1->getX()+n1->getWidth(),n1->getY()+(n1->getHeight()/2));
QPointF B(n1->getX()+(n1->getWidth()/2),n1->getY()+n1->getHeight());
QPointF L(n1->getX(),n1->getY()+(n1->getHeight()/2));
QPointF middleN1(n1->getX()+n1->getWidth()/2,n1->getY()+n1->getHeight()/2); //centre du noeud1
QPointF middleN2(n2->getX()+n2->getWidth()/2,n2->getY()+n2->getHeight()/2); //centre du noeud2
QPointF p1(n1->getX(),n1->getY());
QPointF p2(n1->getX()+n1->getWidth(),n1->getY());
QPointF p3(n1->getX()+n1->getWidth(),n1->getY()+n1->getHeight());
QPointF p4(n1->getX(),n1->getY()+n1->getHeight());
/*****************************************
* Methode avec fonctions x=y et -x=y (P1)
*****************************************/
float aEq1 = ( (p1.y()-p3.y()) / (p1.x() - p3.x()) );
float bEq1 = ( (-(aEq1 *p3.x())) + (p3.y()) );
float aEq2 = ( (p4.y()-p2.y()) / (p4.x() - p2.x()) );
float bEq2 = ( (-(aEq2 *p2.x())) + (p2.y()) );
if(middleN2.y() < (aEq1*middleN2.x() + bEq1) && middleN2.y() < (aEq2*middleN2.x() + bEq2) ){
retPoint = T;
}
else if(middleN2.y() <= (aEq1*middleN2.x() + bEq1) && middleN2.y() >= (aEq2*middleN2.x() + bEq2)){
retPoint = R;
}
else if(middleN2.y() > (aEq1*middleN2.x() + bEq1) && middleN2.y() > (aEq2*middleN2.x() + bEq2)){
retPoint = B;
}
else if(middleN2.y() >= (aEq1*middleN2.x() + bEq1) && middleN2.y() <= (aEq2*middleN2.x() + bEq2)){
retPoint = L;
}
}
else if(nodesAreCircles){
/*----------------------------
* Pour des noeud circulaires (P1)
*--------------------------*/
QPointF middleN1(n1->getX()+n1->getWidth()/2,n1->getY()+n1->getHeight()/2); //centre du noeud1
QPointF middleN2(n2->getX()+n2->getWidth()/2,n2->getY()+n2->getHeight()/2); //centre du noeud2
//petites valezurs necessaires, longueure vecteur , rayon , ration longueur/rayon
float longueur_vecteur = sqrt(pow(middleN2.x()-middleN1.x(),2)+pow(middleN2.y()-middleN1.y(),2));
float longueur_rayon = n1->getWidth()/2;
float ratio = longueur_vecteur/longueur_rayon;
//calcul des coordonée du vecteur entre le milieur de N1 et milieu de n2 (sous forme d'un qPoint car ce n'est que deux int)
QPointF v_MiddleN1_MiddleN2(middleN2.x()-middleN1.x(),middleN2.y()-middleN1.y());
//calcul des coordonée du vecteur du rayon de N1
QPointF v_RayonN1(v_MiddleN1_MiddleN2.x()/ratio,v_MiddleN1_MiddleN2.y()/ratio);
//puis ajout la taille du vecteur du rayon au centre du cercle pour avoir le point sur le bord du cercle
QPointF point_sur_cercle(middleN1.x()+v_RayonN1.x(),middleN1.y()+v_RayonN1.y());
retPoint = point_sur_cercle;
}
return retPoint;
}
void BlockType::drawBlock(TriangleCollector *collector, const Block &block) const
{
collector->setCurrentBlock(block);
int type = block.getType();
if (blockTypeSpec[type].type == Type_Cube)
{
const Tile &tile = blockTypeSpec[type].tile;
/* |y
* |
* 1----------2
* /| /|
* / | / |
* / | / |
* 3---+------4 |
* | 5------+---6------x
* | / | /
* | / | /
* |/ |/
* 7----------8
* /
* /z
*/
float3 p1(0, 1, 0);
float3 p2(1, 1, 0);
float3 p3(0, 1, 1);
float3 p4(1, 1, 1);
float3 p5(0, 0, 0);
float3 p6(1, 0, 0);
float3 p7(0, 0, 1);
float3 p8(1, 0, 1);
Block b[3][3][3];
for (int x = -1; x <= 1; x++)
for (int y = -1; y <= 1; y++)
for (int z = -1; z <= 1; z++)
b[x + 1][y + 1][z + 1] = block.getNeighbour(x, y, z);
drawFace(collector, tile, p4, p2, p8, p6,
b[2][2][2], b[2][2][1], b[2][2][0],
b[2][1][2], b[2][1][1], b[2][1][0],
b[2][0][2], b[2][0][1], b[2][0][0],
float3(1, 0, 0));
drawFace(collector, tile, p1, p3, p5, p7,
b[0][2][0], b[0][2][1], b[0][2][2],
b[0][1][0], b[0][1][1], b[0][1][2],
b[0][0][0], b[0][0][1], b[0][0][2],
float3(-1, 0, 0));
drawFace(collector, tile, p1, p2, p3, p4,
b[0][2][0], b[1][2][0], b[2][2][0],
b[0][2][1], b[1][2][1], b[2][2][1],
b[0][2][2], b[1][2][2], b[2][2][2],
float3(0, 1, 0));
drawFace(collector, tile, p7, p8, p5, p6,
b[0][0][2], b[1][0][2], b[2][0][2],
b[0][0][1], b[1][0][1], b[2][0][1],
b[0][0][0], b[1][0][0], b[2][0][0],
float3(0, -1, 0));
drawFace(collector, tile, p3, p4, p7, p8,
b[0][2][2], b[1][2][2], b[2][2][2],
b[0][1][2], b[1][1][2], b[2][1][2],
b[0][0][2], b[1][0][2], b[2][0][2],
float3(0, 0, 1));
drawFace(collector, tile, p2, p1, p6, p5,
b[2][2][0], b[1][2][0], b[0][2][0],
b[2][1][0], b[1][1][0], b[0][1][0],
b[2][0][0], b[1][0][0], b[0][0][0],
float3(0, 0, -1));
}
}
QImage* MyWidget::transform_back() const
{
if(!image_save || frames.size() == 0 || frames_save.size() == 0)
return image_save;
uint w = image_save->width(),
h = image_save->height();
QImage *new_img = new QImage(w,h,QImage::Format_RGB32);
QPainter painter;
painter.begin(new_img);
QBrush brush(QColor(0,0,0));
QPen pen(QColor(0,0,0));
painter.setBrush(brush);
painter.setPen(pen);
painter.drawRect(QRect(0,0,w-1,h-1));
painter.end();
for(uint i=0;i<frames.size();++i)
{
auto v2 = &frames, v1 = &frames_save;
QPoint p1(v1->at(i).getPoint(0)), p2(v1->at(i).getPoint(1)),p3(v1->at(i).getPoint(2)),p4(v1->at(i).getPoint(3)),
op1(v2->at(i).getPoint(0)), op2(v2->at(i).getPoint(1)), op3(v2->at(i).getPoint(2)), op4(v2->at(i).getPoint(3));
std::vector<QPoint>
vpi{p1,p2,p3,p4},
vpo{op1,op2,op3,op4};
BilineTransform pt;
pt.generateFromPoints(vpo, vpi);
pt.transformImage(*image_save, *new_img, v2->at(i));
}
return new_img;
}
int main()
{
CGAL_KD_SETDTHREAD(11);
CGAL::set_pretty_mode ( std::cerr );
CGAL_TEST_START;
{
typedef CGAL::Homogeneous_d<RT> Kernel;
typedef CGAL::Convex_hull_d<Kernel> Convex_hull_d;
typedef Convex_hull_d::Point_d Point;
typedef Convex_hull_d::Hyperplane_d Plane;
typedef Convex_hull_d::Simplex_handle Simplex_handle;
typedef Convex_hull_d::Facet_handle Facet_handle;
typedef Convex_hull_d::Vertex_handle Vertex_handle;
Convex_hull_d T1(2);
const Convex_hull_d* pT1 = &T1;
Point p1(0,0,1);
Point p2(1,0,1);
Point p3(0,1,1);
Point p4(1,1,1);
CGAL_TEST(T1.dimension()==2);
CGAL_TEST(T1.current_dimension()==-1);
Vertex_handle v1 = T1.insert(p1);
CGAL_TEST(T1.associated_point(v1)==p1);
T1.insert(p2);
CGAL_TEST(T1.current_dimension()==1);
CGAL_TEST(T1.is_dimension_jump(p3));
T1.insert(p3);
Simplex_handle s1 = T1.simplex(v1);
int i1 = T1.index(v1);
CGAL_TEST(T1.vertex_of_simplex(s1,i1)==v1);
CGAL_TEST(T1.associated_point(T1.vertex_of_simplex(s1,1))==
T1.point_of_simplex(s1,1));
T1.insert(p3);
CGAL_TEST((T1.opposite_simplex(T1.opposite_simplex(s1,1),
T1.index_of_vertex_in_opposite_simplex(s1,1)) == s1));
std::list<Simplex_handle> L = T1.all_simplices();
CGAL_TEST(L.size() == 4);
std::list<Facet_handle> F = T1.all_facets();
CGAL_TEST(F.size() == 3);
Facet_handle f1 = *(L.begin());
CGAL_TEST(T1.associated_point(T1.vertex_of_facet(f1,1))==
T1.point_of_facet(f1,1));
CGAL_TEST((T1.opposite_facet(T1.opposite_facet(f1,1),
T1.index_of_vertex_in_opposite_facet(f1,1)) == f1));
Point pf0 = T1.point_of_facet(f1,0);
Point pf1 = T1.point_of_facet(f1,1);
Plane h = T1.hyperplane_supporting(f1);
CGAL_TEST(h.has_on(pf0)&&h.has_on(pf1));
std::list<Facet_handle> G = T1.facets_visible_from(p4);
CGAL_TEST(G.size()==1);
CGAL_TEST(T1.bounded_side(p4)==CGAL::ON_UNBOUNDED_SIDE &&
T1.bounded_side(Point(1,1,10))==CGAL::ON_BOUNDED_SIDE);
Convex_hull_d::Point_const_iterator pit;
Convex_hull_d::Vertex_iterator vit;
Convex_hull_d::Simplex_iterator sit;
for (pit = T1.points_begin(); pit != T1.points_end(); pit++) *pit;
for (vit = T1.vertices_begin(); vit != T1.vertices_end(); vit++) *vit;
for (sit = T1.simplices_begin(); sit != T1.simplices_end(); sit++) *sit;
T1.is_valid();
T1.clear(2);
CGAL_TEST(T1.number_of_vertices()==0);
CGAL_TEST(T1.number_of_facets()==0);
CGAL_TEST(T1.number_of_simplices()==0);
std::vector<Point> V = make_vector(p1,p2,p3,p4);
T1.initialize(V.begin(),V.end());
Convex_hull_d::Facet_iterator fit;
int fnum(0);
for (fit = T1.facets_begin(); fit != T1.facets_end(); ++fnum, ++fit) *fit;
CGAL_TEST(fnum==4);
#ifndef _MSC_VER // truncation due to name length exceeded
Convex_hull_d::Hull_vertex_iterator hvit;
int vnum(0);
for (hvit = T1.hull_vertices_begin();
hvit != T1.hull_vertices_end(); ++vnum, ++hvit) *hvit;
CGAL_TEST(vnum==4);
Convex_hull_d::Facet_const_iterator fcit;
for (fcit = pT1->facets_begin(); fcit != pT1->facets_end(); ++fcit) *fcit;
Convex_hull_d::Hull_vertex_const_iterator hvcit;
for (hvcit = pT1->hull_vertices_begin();
hvcit != pT1->hull_vertices_end(); ++hvcit) *hvcit;
Convex_hull_d::Hull_point_const_iterator hpcit;
for (hpcit = pT1->hull_points_begin();
hpcit != pT1->hull_points_end(); ++hpcit) *hpcit;
#endif
}
{
typedef CGAL::Cartesian<double> Kernel_3;
typedef CGAL::Convex_hull_d_traits_3<Kernel_3> Kernel;
typedef CGAL::Convex_hull_d<Kernel> Convex_hull_d;
typedef Convex_hull_d::Point_d Point;
typedef Convex_hull_d::Hyperplane_d Plane;
typedef Convex_hull_d::Simplex_handle Simplex_handle;
typedef Convex_hull_d::Facet_handle Facet_handle;
typedef Convex_hull_d::Vertex_handle Vertex_handle;
Convex_hull_d T2(3);
Point p1(0,0,0,1);
Point p2(1,0,0,1);
Point p3(0,1,0,1);
Point p4(0,0,1,1);
Point p5(1,1,1,1);
CGAL_TEST(T2.dimension()==3);
CGAL_TEST(T2.current_dimension()==-1);
T2.insert(p1);
T2.insert(p2);
CGAL_TEST(T2.is_dimension_jump(p3));
T2.insert(p3);
CGAL_TEST(T2.current_dimension()==2);
CGAL_TEST(T2.is_dimension_jump(p4));
Vertex_handle v1 = T2.insert(p4);
CGAL_TEST(T2.associated_point(v1)==p4);
Simplex_handle s1 = T2.simplex(v1);
int i1 = T2.index(v1);
CGAL_TEST(T2.vertex_of_simplex(s1,i1)==v1);
CGAL_TEST(T2.associated_point(T2.vertex_of_simplex(s1,1))==
T2.point_of_simplex(s1,1));
CGAL_TEST((T2.opposite_simplex(T2.opposite_simplex(s1,1),
T2.index_of_vertex_in_opposite_simplex(s1,1)) == s1));
std::list<Simplex_handle> L = T2.all_simplices();
CGAL_TEST(L.size() == 5);
std::list<Facet_handle> F = T2.all_facets();
CGAL_TEST(F.size() == 4);
Facet_handle f1 = *(L.begin());
CGAL_TEST(T2.associated_point(T2.vertex_of_facet(f1,1))==
T2.point_of_facet(f1,1));
CGAL_TEST((T2.opposite_facet(T2.opposite_facet(f1,1),
T2.index_of_vertex_in_opposite_facet(f1,1)) == f1));
Point pf0 = T2.point_of_facet(f1,0);
Point pf1 = T2.point_of_facet(f1,1);
Point pf2 = T2.point_of_facet(f1,2);
Plane h = T2.hyperplane_supporting(f1);
CGAL_TEST(h.has_on(pf0)&&h.has_on(pf1)&&h.has_on(pf2));
std::list<Facet_handle> G = T2.facets_visible_from(p5);
CGAL_TEST(G.size()==1);
CGAL_TEST(T2.bounded_side(p5)==CGAL::ON_UNBOUNDED_SIDE &&
T2.bounded_side(Point(1,1,1,10))==CGAL::ON_BOUNDED_SIDE);
T2.is_valid();
T2.clear(3);
}
{
typedef CGAL::Homogeneous<RT> Kernel_3;
typedef CGAL::Convex_hull_d_traits_3<Kernel_3> Kernel;
typedef CGAL::Convex_hull_d<Kernel> Convex_hull_d;
typedef Convex_hull_d::Point_d Point;
typedef Convex_hull_d::Hyperplane_d Plane;
typedef Convex_hull_d::Simplex_handle Simplex_handle;
typedef Convex_hull_d::Facet_handle Facet_handle;
typedef Convex_hull_d::Vertex_handle Vertex_handle;
Convex_hull_d T2(3);
Point p1(0,0,0,1);
Point p2(1,0,0,1);
Point p3(0,1,0,1);
Point p4(0,0,1,1);
Point p5(1,1,1,1);
CGAL_TEST(T2.dimension()==3);
CGAL_TEST(T2.current_dimension()==-1);
T2.insert(p1);
T2.insert(p2);
CGAL_TEST(T2.is_dimension_jump(p3));
T2.insert(p3);
CGAL_TEST(T2.current_dimension()==2);
CGAL_TEST(T2.is_dimension_jump(p4));
Vertex_handle v1 = T2.insert(p4);
CGAL_TEST(T2.associated_point(v1)==p4);
Simplex_handle s1 = T2.simplex(v1);
int i1 = T2.index(v1);
CGAL_TEST(T2.vertex_of_simplex(s1,i1)==v1);
CGAL_TEST(T2.associated_point(T2.vertex_of_simplex(s1,1))==
T2.point_of_simplex(s1,1));
CGAL_TEST((T2.opposite_simplex(T2.opposite_simplex(s1,1),
T2.index_of_vertex_in_opposite_simplex(s1,1)) == s1));
std::list<Simplex_handle> L = T2.all_simplices();
CGAL_TEST(L.size() == 5);
std::list<Facet_handle> F = T2.all_facets();
CGAL_TEST(F.size() == 4);
Facet_handle f1 = *(L.begin());
CGAL_TEST(T2.associated_point(T2.vertex_of_facet(f1,1))==
T2.point_of_facet(f1,1));
CGAL_TEST((T2.opposite_facet(T2.opposite_facet(f1,1),
T2.index_of_vertex_in_opposite_facet(f1,1)) == f1));
Point pf0 = T2.point_of_facet(f1,0);
Point pf1 = T2.point_of_facet(f1,1);
Point pf2 = T2.point_of_facet(f1,2);
Plane h = T2.hyperplane_supporting(f1);
CGAL_TEST(h.has_on(pf0)&&h.has_on(pf1)&&h.has_on(pf2));
std::list<Facet_handle> G = T2.facets_visible_from(p5);
CGAL_TEST(G.size()==1);
CGAL_TEST(T2.bounded_side(p5)==CGAL::ON_UNBOUNDED_SIDE &&
T2.bounded_side(Point(1,1,1,10))==CGAL::ON_BOUNDED_SIDE);
T2.is_valid();
T2.clear(3);
}
{
typedef CGAL::Cartesian_d<double> Kernel;
typedef CGAL::Convex_hull_d<Kernel> Convex_hull_d;
typedef Convex_hull_d::Point_d Point;
typedef Convex_hull_d::Hyperplane_d Plane;
typedef Convex_hull_d::Simplex_handle Simplex_handle;
typedef Convex_hull_d::Facet_handle Facet_handle;
typedef Convex_hull_d::Vertex_handle Vertex_handle;
Convex_hull_d T2(3);
Point p1(0,0,0,1);
Point p2(1,0,0,1);
Point p3(0,1,0,1);
Point p4(0,0,1,1);
Point p5(1,1,1,1);
CGAL_TEST(T2.dimension()==3);
CGAL_TEST(T2.current_dimension()==-1);
T2.insert(p1);
T2.insert(p2);
CGAL_TEST(T2.is_dimension_jump(p3));
T2.insert(p3);
CGAL_TEST(T2.current_dimension()==2);
CGAL_TEST(T2.is_dimension_jump(p4));
Vertex_handle v1 = T2.insert(p4);
CGAL_TEST(T2.associated_point(v1)==p4);
Simplex_handle s1 = T2.simplex(v1);
int i1 = T2.index(v1);
CGAL_TEST(T2.vertex_of_simplex(s1,i1)==v1);
CGAL_TEST(T2.associated_point(T2.vertex_of_simplex(s1,1))==
T2.point_of_simplex(s1,1));
CGAL_TEST((T2.opposite_simplex(T2.opposite_simplex(s1,1),
T2.index_of_vertex_in_opposite_simplex(s1,1)) == s1));
std::list<Simplex_handle> L = T2.all_simplices();
CGAL_TEST(L.size() == 5);
std::list<Facet_handle> F = T2.all_facets();
CGAL_TEST(F.size() == 4);
Facet_handle f1 = *(L.begin());
CGAL_TEST(T2.associated_point(T2.vertex_of_facet(f1,1))==
T2.point_of_facet(f1,1));
CGAL_TEST((T2.opposite_facet(T2.opposite_facet(f1,1),
T2.index_of_vertex_in_opposite_facet(f1,1)) == f1));
Point pf0 = T2.point_of_facet(f1,0);
Point pf1 = T2.point_of_facet(f1,1);
Point pf2 = T2.point_of_facet(f1,2);
Plane h = T2.hyperplane_supporting(f1);
CGAL_TEST(h.has_on(pf0)&&h.has_on(pf1)&&h.has_on(pf2));
std::list<Facet_handle> G = T2.facets_visible_from(p5);
CGAL_TEST(G.size()==1);
CGAL_TEST(T2.bounded_side(p5)==CGAL::ON_UNBOUNDED_SIDE &&
T2.bounded_side(Point(1,1,1,10))==CGAL::ON_BOUNDED_SIDE);
T2.is_valid();
T2.clear(3);
}
{
typedef CGAL::Homogeneous_d<RT> Kernel;
typedef CGAL::Convex_hull_d<Kernel> Convex_hull_d;
typedef Convex_hull_d::Point_d Point;
typedef Convex_hull_d::Hyperplane_d Plane;
typedef Convex_hull_d::Simplex_handle Simplex_handle;
typedef Convex_hull_d::Facet_handle Facet_handle;
typedef Convex_hull_d::Vertex_handle Vertex_handle;
Convex_hull_d T2(3);
Point p1(0,0,0,1);
Point p2(1,0,0,1);
Point p3(0,1,0,1);
Point p4(0,0,1,1);
Point p5(1,1,1,1);
CGAL_TEST(T2.dimension()==3);
CGAL_TEST(T2.current_dimension()==-1);
T2.insert(p1);
T2.insert(p2);
CGAL_TEST(T2.is_dimension_jump(p3));
T2.insert(p3);
CGAL_TEST(T2.current_dimension()==2);
CGAL_TEST(T2.is_dimension_jump(p4));
Vertex_handle v1 = T2.insert(p4);
CGAL_TEST(T2.associated_point(v1)==p4);
Simplex_handle s1 = T2.simplex(v1);
int i1 = T2.index(v1);
CGAL_TEST(T2.vertex_of_simplex(s1,i1)==v1);
CGAL_TEST(T2.associated_point(T2.vertex_of_simplex(s1,1))==
T2.point_of_simplex(s1,1));
CGAL_TEST((T2.opposite_simplex(T2.opposite_simplex(s1,1),
T2.index_of_vertex_in_opposite_simplex(s1,1)) == s1));
std::list<Simplex_handle> L = T2.all_simplices();
CGAL_TEST(L.size() == 5);
std::list<Facet_handle> F = T2.all_facets();
CGAL_TEST(F.size() == 4);
Facet_handle f1 = *(L.begin());
CGAL_TEST(T2.associated_point(T2.vertex_of_facet(f1,1))==
T2.point_of_facet(f1,1));
CGAL_TEST((T2.opposite_facet(T2.opposite_facet(f1,1),
T2.index_of_vertex_in_opposite_facet(f1,1)) == f1));
Point pf0 = T2.point_of_facet(f1,0);
Point pf1 = T2.point_of_facet(f1,1);
Point pf2 = T2.point_of_facet(f1,2);
Plane h = T2.hyperplane_supporting(f1);
CGAL_TEST(h.has_on(pf0)&&h.has_on(pf1)&&h.has_on(pf2));
std::list<Facet_handle> G = T2.facets_visible_from(p5);
CGAL_TEST(G.size()==1);
CGAL_TEST(T2.bounded_side(p5)==CGAL::ON_UNBOUNDED_SIDE &&
T2.bounded_side(Point(1,1,1,10))==CGAL::ON_BOUNDED_SIDE);
T2.is_valid();
T2.clear(3);
}
CGAL_TEST_END;
}
void dgCollisionSphere::Init (dgFloat32 radius, dgMemoryAllocator* allocator)
{
m_rtti |= dgCollisionSphere_RTTI;
m_radius = radius;
m_edgeCount = DG_SPHERE_EDGE_COUNT;
m_vertexCount = DG_SPHERE_VERTEX_COUNT;
dgCollisionConvex::m_vertex = m_vertex;
if (!m_shapeRefCount) {
dgInt32 indexList[256];
dgVector tmpVectex[256];
dgVector p0 ( dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (0.0f));
dgVector p1 (-dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (0.0f));
dgVector p2 ( dgFloat32 (0.0f), dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f));
dgVector p3 ( dgFloat32 (0.0f),-dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f));
dgVector p4 ( dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (1.0f), dgFloat32 (0.0f));
dgVector p5 ( dgFloat32 (0.0f), dgFloat32 (0.0f),-dgFloat32 (1.0f), dgFloat32 (0.0f));
dgInt32 i = 1;
dgInt32 count = 0;
TesselateTriangle (i, p4, p0, p2, count, tmpVectex);
TesselateTriangle (i, p4, p2, p1, count, tmpVectex);
TesselateTriangle (i, p4, p1, p3, count, tmpVectex);
TesselateTriangle (i, p4, p3, p0, count, tmpVectex);
TesselateTriangle (i, p5, p2, p0, count, tmpVectex);
TesselateTriangle (i, p5, p1, p2, count, tmpVectex);
TesselateTriangle (i, p5, p3, p1, count, tmpVectex);
TesselateTriangle (i, p5, p0, p3, count, tmpVectex);
//dgAssert (count == EDGE_COUNT);
dgInt32 vertexCount = dgVertexListToIndexList (&tmpVectex[0].m_x, sizeof (dgVector), 3 * sizeof (dgFloat32), 0, count, indexList, 0.001f);
dgAssert (vertexCount == DG_SPHERE_VERTEX_COUNT);
for (dgInt32 i = 0; i < vertexCount; i ++) {
m_unitSphere[i] = tmpVectex[i];
}
dgPolyhedra polyhedra(m_allocator);
polyhedra.BeginFace();
for (dgInt32 i = 0; i < count; i += 3) {
#ifdef _DEBUG
dgEdge* const edge = polyhedra.AddFace (indexList[i], indexList[i + 1], indexList[i + 2]);
dgAssert (edge);
#else
polyhedra.AddFace (indexList[i], indexList[i + 1], indexList[i + 2]);
#endif
}
polyhedra.EndFace();
dgUnsigned64 i1 = 0;
dgPolyhedra::Iterator iter (polyhedra);
for (iter.Begin(); iter; iter ++) {
dgEdge* const edge = &(*iter);
edge->m_userData = i1;
i1 ++;
}
for (iter.Begin(); iter; iter ++) {
dgEdge* const edge = &(*iter);
dgConvexSimplexEdge* const ptr = &m_edgeArray[edge->m_userData];
ptr->m_vertex = edge->m_incidentVertex;
ptr->m_next = &m_edgeArray[edge->m_next->m_userData];
ptr->m_prev = &m_edgeArray[edge->m_prev->m_userData];
ptr->m_twin = &m_edgeArray[edge->m_twin->m_userData];
}
}
for (dgInt32 i = 0; i < DG_SPHERE_VERTEX_COUNT; i ++) {
m_vertex[i] = m_unitSphere[i].Scale4 (m_radius);
}
m_shapeRefCount ++;
dgCollisionConvex::m_simplex = m_edgeArray;
SetVolumeAndCG ();
}
void Tie::computeBezier(SlurSegment* ss, QPointF p6o)
{
qreal _spatium = spatium();
qreal shoulderW; // height as fraction of slur-length
qreal shoulderH;
//
// pp1 start of slur
// pp2 end of slur
// pp3 bezier 1
// pp4 bezier 2
// pp5 drag
// pp6 shoulder
//
QPointF pp1 = ss->ups[GRIP_START].p + ss->ups[GRIP_START].off * _spatium;
QPointF pp2 = ss->ups[GRIP_END].p + ss->ups[GRIP_END].off * _spatium;
QPointF p2 = pp2 - pp1; // normalize to zero
if (p2.x() == 0.0) {
qDebug("zero tie");
return;
}
qreal sinb = atan(p2.y() / p2.x());
QTransform t;
t.rotateRadians(-sinb);
p2 = t.map(p2);
p6o = t.map(p6o);
double smallH = 0.38;
qreal d = p2.x() / _spatium;
shoulderH = d * 0.4 * smallH;
if (shoulderH > 1.3) // maximum tie shoulder height
shoulderH = 1.3;
shoulderH *= _spatium;
shoulderW = .6;
shoulderH -= p6o.y();
if (!up())
shoulderH = -shoulderH;
qreal c = p2.x();
qreal c1 = (c - c * shoulderW) * .5 + p6o.x();
qreal c2 = c1 + c * shoulderW + p6o.x();
QPointF p5 = QPointF(c * .5, 0.0);
QPointF p3(c1, -shoulderH);
QPointF p4(c2, -shoulderH);
qreal w = (score()->styleS(ST_SlurMidWidth).val() - score()->styleS(ST_SlurEndWidth).val()) * _spatium;
QPointF th(0.0, w); // thickness of slur
QPointF p3o = p6o + t.map(ss->ups[GRIP_BEZIER1].off * _spatium);
QPointF p4o = p6o + t.map(ss->ups[GRIP_BEZIER2].off * _spatium);
if(!p6o.isNull()) {
QPointF p6i = t.inverted().map(p6o) / _spatium;
ss->ups[GRIP_BEZIER1].off += p6i ;
ss->ups[GRIP_BEZIER2].off += p6i;
}
//-----------------------------------calculate p6
QPointF pp3 = p3 + p3o;
QPointF pp4 = p4 + p4o;
QPointF ppp4 = pp4 - pp3;
qreal r2 = atan(ppp4.y() / ppp4.x());
t.reset();
t.rotateRadians(-r2);
QPointF p6 = QPointF(t.map(ppp4).x() * .5, 0.0);
t.rotateRadians(2 * r2);
p6 = t.map(p6) + pp3 - p6o;
//-----------------------------------
ss->path = QPainterPath();
ss->path.moveTo(QPointF());
ss->path.cubicTo(p3 + p3o - th, p4 + p4o - th, p2);
if (lineType() == 0)
ss->path.cubicTo(p4 +p4o + th, p3 + p3o + th, QPointF());
th = QPointF(0.0, 3.0 * w);
ss->shapePath = QPainterPath();
ss->shapePath.moveTo(QPointF());
ss->shapePath.cubicTo(p3 + p3o - th, p4 + p4o - th, p2);
ss->shapePath.cubicTo(p4 +p4o + th, p3 + p3o + th, QPointF());
// translate back
t.reset();
t.translate(pp1.x(), pp1.y());
t.rotateRadians(sinb);
ss->path = t.map(ss->path);
ss->shapePath = t.map(ss->shapePath);
ss->ups[GRIP_BEZIER1].p = t.map(p3);
ss->ups[GRIP_BEZIER2].p = t.map(p4);
ss->ups[GRIP_END].p = t.map(p2) - ss->ups[GRIP_END].off * _spatium;
ss->ups[GRIP_DRAG].p = t.map(p5);
ss->ups[GRIP_SHOULDER].p = t.map(p6);
}
int main(int argc, const char* argv[])
{
try
{
//init park
Park disneyWorld("Disney World",10,15,100);
//init operators
Operator o1(Person("Keren", 19, 1.85));
Operator o2(Person("Daniel", 21, 1.75));
Operator o3(Person("Amir", 26, 1.60));
Operator o4(Person("Eytan", 28, 1.80));
disneyWorld += o1;
disneyWorld += o2;
disneyWorld += o3;
disneyWorld += o4;
//init facilities
bool ageTypes[] = {true, true, false};
WaterSlide waterSlide(Facility("KAMIKAZA", 2 , ageTypes, &o1), 800);
ageTypes[2] = true;
RollerCoaster rollerCoasterA(Facility("BALERINE", 30, ageTypes, &o2), 4, 0);
ageTypes[0] = false;
RollerCoaster rollerCoasterB(Facility("ANACONDA", 16, ageTypes, &o3), 30, 2);
ageTypes[2] = false;
Facility f("HYDRA", 12, ageTypes, &o4);
WaterRollerCoaster waterRollerCoaster(WaterSlide(f,1000), RollerCoaster(f, 40, 7));
disneyWorld += waterSlide;
disneyWorld += rollerCoasterA;
disneyWorld += rollerCoasterB;
disneyWorld += waterRollerCoaster;
//create persons to enter park
Person p1("Adam",13,1.25);
Person p2("Adir", 21, 1.55);
Person p3("Adi", 27, 1.68);
Person p4("Adva", 72, 1.45);
Guest& g1 = disneyWorld.buyTicket(p1, Guest::CHILD, Guest::THRILLED,"09/09/2015");
Guest& g2 = disneyWorld.buyTicket(p2, Guest::ADULT, Guest::HAPPY,"09/09/2015" ,true);
Guest& g3 = disneyWorld.buyTicket(p3, Guest::ADULT, Guest::HAPPY,"08/09/2015");
Guest& g4 = disneyWorld.buyTicket(p4, Guest::CHILD, Guest::AFRAID,"05/09/2015");
//add guest to facility
waterSlide += g1;
waterSlide += g2;
waterSlide.start(); //start() should remove all guests
waterSlide += g3;
waterSlide += g4;
waterSlide.start();
rollerCoasterA += g1;
rollerCoasterA += g2;
rollerCoasterA += g3;
rollerCoasterA += g4;
waterRollerCoaster += g1;
waterRollerCoaster += g2;
waterRollerCoaster += g3;
waterRollerCoaster += g4;
cout << disneyWorld << endl;
rollerCoasterA.start();
waterRollerCoaster.start();
cout << disneyWorld << endl;
}
catch(const char* msg)
{
cout << "Problem occured..." << endl;
cout << msg << endl;
cout << "Finishing.." << endl;
}
}
// Create mesh
void Chunk::CreateMesh()
{
if (m_pMesh == NULL)
{
m_pMesh = m_pRenderer->CreateMesh(OGLMeshType_Textured);
}
int *l_merged;
l_merged = new int[CHUNK_SIZE_CUBED];
for (unsigned int j = 0; j < CHUNK_SIZE_CUBED; j++)
{
l_merged[j] = MergedSide_None;
}
float r = 1.0f;
float g = 1.0f;
float b = 1.0f;
float a = 1.0f;
for (int x = 0; x < CHUNK_SIZE; x++)
{
for (int y = 0; y < CHUNK_SIZE; y++)
{
for (int z = 0; z < CHUNK_SIZE; z++)
{
if (GetActive(x, y, z) == false)
{
continue;
}
else
{
GetColour(x, y, z, &r, &g, &b, &a);
a = 1.0f;
vec3 p1(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
vec3 p2(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
vec3 p3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
vec3 p4(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
vec3 p5(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
vec3 p6(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
vec3 p7(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
vec3 p8(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
vec3 n1;
unsigned int v1, v2, v3, v4;
unsigned int t1, t2, t3, t4;
bool doXPositive = (IsMergedXPositive(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
bool doXNegative = (IsMergedXNegative(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
bool doYPositive = (IsMergedYPositive(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
bool doYNegative = (IsMergedYNegative(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
bool doZPositive = (IsMergedZPositive(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
bool doZNegative = (IsMergedZNegative(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE) == false);
// Front
if (doZPositive && ((z == CHUNK_SIZE - 1) || z < CHUNK_SIZE - 1 && GetActive(x, y, z + 1) == false))
{
bool addSide = true;
if ((z == CHUNK_SIZE - 1))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX, m_gridY, m_gridZ + 1);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(x, y, 0) == false);
}
}
if (addSide)
{
int endX = (x / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (y / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p1, &p2, &p3, &p4, x, y, endX, endY, true, true, false, false);
}
n1 = vec3(0.0f, 0.0f, 1.0f);
v1 = m_pRenderer->AddVertexToMesh(p1, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p2, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p3, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p4, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
p1 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p2 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p3 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p4 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p5 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p6 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p7 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p8 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
// Back
if (doZNegative && ((z == 0) || (z > 0 && GetActive(x, y, z - 1) == false)))
{
bool addSide = true;
if ((z == 0))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX, m_gridY, m_gridZ - 1);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(x, y, CHUNK_SIZE - 1) == false);
}
}
if (addSide)
{
int endX = (x / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (y / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p6, &p5, &p8, &p7, x, y, endX, endY, false, true, false, false);
}
n1 = vec3(0.0f, 0.0f, -1.0f);
v1 = m_pRenderer->AddVertexToMesh(p5, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p6, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p7, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p8, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
p1 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p2 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p3 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p4 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p5 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p6 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p7 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p8 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
// Right
if (doXPositive && ((x == CHUNK_SIZE - 1) || (x < CHUNK_SIZE - 1 && GetActive(x + 1, y, z) == false)))
{
bool addSide = true;
if ((x == CHUNK_SIZE - 1))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX + 1, m_gridY, m_gridZ);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(0, y, z) == false);
}
}
if (addSide)
{
int endX = (z / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (y / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p5, &p2, &p3, &p8, z, y, endX, endY, true, false, true, false);
}
n1 = vec3(1.0f, 0.0f, 0.0f);
v1 = m_pRenderer->AddVertexToMesh(p2, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p5, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p8, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p3, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
p1 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p2 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p3 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p4 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p5 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p6 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p7 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p8 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
// Left
if (doXNegative && ((x == 0) || (x > 0 && GetActive(x - 1, y, z) == false)))
{
bool addSide = true;
if ((x == 0))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX - 1, m_gridY, m_gridZ);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(CHUNK_SIZE - 1, y, z) == false);
}
}
if (addSide)
{
int endX = (z / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (y / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p6, &p1, &p4, &p7, z, y, endX, endY, false, false, true, false);
}
n1 = vec3(-1.0f, 0.0f, 0.0f);
v1 = m_pRenderer->AddVertexToMesh(p6, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p1, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p4, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p7, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
p1 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p2 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p3 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p4 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p5 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p6 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p7 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p8 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
// Top
if (doYPositive && ((y == CHUNK_SIZE - 1) || (y < CHUNK_SIZE - 1 && GetActive(x, y + 1, z) == false)))
{
bool addSide = true;
if ((y == CHUNK_SIZE - 1))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX, m_gridY + 1, m_gridZ);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(x, 0, z) == false);
}
}
if (addSide)
{
int endX = (x / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (z / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p7, &p8, &p3, &p4, x, z, endX, endY, true, false, false, true);
}
n1 = vec3(0.0f, 1.0f, 0.0f);
v1 = m_pRenderer->AddVertexToMesh(p4, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p3, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p8, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p7, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
p1 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p2 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p3 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p4 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z + BLOCK_RENDER_SIZE);
p5 = vec3(x + BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p6 = vec3(x - BLOCK_RENDER_SIZE, y - BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p7 = vec3(x - BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
p8 = vec3(x + BLOCK_RENDER_SIZE, y + BLOCK_RENDER_SIZE, z - BLOCK_RENDER_SIZE);
// Bottom
if (doYNegative && ((y == 0) || (y > 0 && GetActive(x, y - 1, z) == false)))
{
bool addSide = true;
if ((y == 0))
{
Chunk* pChunk = m_pChunkManager->GetChunk(m_gridX, m_gridY - 1, m_gridZ);
if (pChunk == NULL || pChunk->IsSetup())
{
addSide = pChunk != NULL && (pChunk->GetActive(x, CHUNK_SIZE - 1, z) == false);
}
}
if (addSide)
{
int endX = (x / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
int endY = (z / CHUNK_SIZE) * CHUNK_SIZE + CHUNK_SIZE;
if (m_pChunkManager->GetFaceMerging())
{
UpdateMergedSide(l_merged, x, y, z, CHUNK_SIZE, CHUNK_SIZE, &p6, &p5, &p2, &p1, x, z, endX, endY, false, false, false, true);
}
n1 = vec3(0.0f, -1.0f, 0.0f);
v1 = m_pRenderer->AddVertexToMesh(p6, n1, r, g, b, a, m_pMesh);
t1 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 0.0f, m_pMesh);
v2 = m_pRenderer->AddVertexToMesh(p5, n1, r, g, b, a, m_pMesh);
t2 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 0.0f, m_pMesh);
v3 = m_pRenderer->AddVertexToMesh(p2, n1, r, g, b, a, m_pMesh);
t3 = m_pRenderer->AddTextureCoordinatesToMesh(1.0f, 1.0f, m_pMesh);
v4 = m_pRenderer->AddVertexToMesh(p1, n1, r, g, b, a, m_pMesh);
t4 = m_pRenderer->AddTextureCoordinatesToMesh(0.0f, 1.0f, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v2, v3, m_pMesh);
m_pRenderer->AddTriangleToMesh(v1, v3, v4, m_pMesh);
}
}
}
}
}
}
// Delete the merged array
delete l_merged;
}
int main (int argc, char** argv)
{
UnitTest t (32);
// Path ();
Path p0;
t.is (p0._data, "", "Path::Path");
// Path (const Path&);
Path p1 = Path ("foo");
t.is (p1._data, Directory::cwd () + "/foo", "Path::operator=");
// Path (const std::string&);
Path p2 ("~");
t.ok (p2._data != "~", "~ expanded to " + p2._data);
Path p3 ("/tmp");
t.ok (p3._data == "/tmp", "/tmp -> /tmp");
// Path& operator= (const Path&);
Path p3_copy (p3);
t.is (p3._data, p3_copy._data, "Path::Path (Path&)");
// operator (std::string) const;
t.is ((std::string) p3, "/tmp", "Path::operator (std::string) const");
// std::string name () const;
Path p4 ("/a/b/c/file.ext");
t.is (p4.name (), "file.ext", "/a/b/c/file.ext name is file.ext");
// std::string parent () const;
t.is (p4.parent (), "/a/b/c", "/a/b/c/file.ext parent is /a/b/c");
// std::string extension () const;
t.is (p4.extension (), "ext", "/a/b/c/file.ext extension is ext");
// bool exists () const;
t.ok (p2.exists (), "~ exists");
t.ok (p3.exists (), "/tmp exists");
// bool is_directory () const;
t.ok (p2.is_directory (), "~ is_directory");
t.ok (p3.is_directory (), "/tmp is_directory");
// bool readable () const;
t.ok (p2.readable (), "~ readable");
t.ok (p3.readable (), "/tmp readable");
// bool writable () const;
t.ok (p2.writable (), "~ writable");
t.ok (p3.writable (), "/tmp writable");
// bool executable () const;
t.ok (p2.executable (), "~ executable");
t.ok (p3.executable (), "/tmp executable");
// static std::string expand (const std::string&);
t.ok (Path::expand ("~") != "~", "Path::expand ~ != ~");
t.ok (Path::expand ("~/") != "~/", "Path::expand ~/ != ~/");
// static std::vector <std::string> glob (const std::string&);
std::vector <std::string> out = Path::glob ("/tmp");
t.ok (out.size () == 1, "/tmp -> 1 result");
t.is (out[0], "/tmp", "/tmp -> /tmp");
out = Path::glob ("/t?p");
t.ok (out.size () == 1, "/t?p -> 1 result");
t.is (out[0], "/tmp", "/t?p -> /tmp");
out = Path::glob ("/[s-u]mp");
t.ok (out.size () == 1, "/[s-u]mp -> 1 result");
t.is (out[0], "/tmp", "/[s-u]mp -> /tmp");
// bool is_absolute () const;
t.notok (p0.is_absolute (), "'' !is_absolute");
t.ok (p1.is_absolute (), "foo is_absolute");
t.ok (p2.is_absolute (), "~ is_absolute (after expansion)");
t.ok (p3.is_absolute (), "/tmp is_absolute");
t.ok (p4.is_absolute (), "/a/b/c/file.ext is_absolute");
return 0;
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Bound_Ptr_Test"));
// =========================================================================
// The following test uses the ACE_Strong_Bound_Ptr in a single
// thread of control, hence we use the ACE_Null_Mutex
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) performing synchronous test...\n")));
Parent *parent1 = 0;
ACE_NEW_RETURN (parent1,
Parent,
-1);
ACE_Weak_Bound_Ptr<Parent, ACE_Null_Mutex> p8;
{
// Must get the pointer from the parent object's weak_self_ member.
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p(parent1->weak_self_);
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p1(p);
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p2(p);
ACE_Weak_Bound_Ptr<Parent, ACE_Null_Mutex> p3(p);
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p4(p);
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p5 = p2;
ACE_Strong_Bound_Ptr<Parent, ACE_Null_Mutex> p6 = p3;
ACE_Weak_Bound_Ptr<Parent, ACE_Null_Mutex> p7(p1);
p8 = p2;
p->child_->do_something ();
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Parent instance count is %d, expecting 0\n"),
Parent::instance_count_));
if (Parent::instance_count_ != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) parent instance count not 0...\n")),
-1);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Child instance count is %d, expecting 0\n"),
Child::instance_count_));
if (Child::instance_count_ != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) child instance count not 0...\n")),
-1);
}
// Weak pointer should now be set to null.
if(!p8.null ())
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) p8 not nill...\n")),
-1);
}
Printer *printer1 = 0;
ACE_NEW_RETURN (printer1,
Printer ("I am printer 1"),
-1);
ACE_Weak_Bound_Ptr<Printer, ACE_Null_Mutex> r9;
{
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r(printer1);
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r1(r);
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r2(r);
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r3(r);
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r4(r);
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r5 = r2;
ACE_Strong_Bound_Ptr<Printer, ACE_Null_Mutex> r6 = r1;
ACE_Weak_Bound_Ptr<Printer, ACE_Null_Mutex> r7(r1);
ACE_Weak_Bound_Ptr<Printer, ACE_Null_Mutex> r8 = r2;
r9 = r3;
r9->print ();
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Printer instance count is %d, expecting 0\n"),
Printer::instance_count_));
if (Printer::instance_count_ != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) Printer instance count not 0...\n")),
-1);
}
// Weak pointer should now be set to null.
if (!r9.null ())
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) r9 not nill...\n")),
-1);
}
#if defined (ACE_HAS_THREADS)
// =========================================================================
// The following test uses the ACE_Strong_Bound_Ptr in multiple
// threads of control.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) performing asynchronous test...\n")));
Scheduler *scheduler_ptr = 0;
// Create active objects..
ACE_NEW_RETURN (scheduler_ptr,
Scheduler (),
-1);
ACE_Strong_Bound_Ptr<Scheduler, ACE_Null_Mutex> scheduler(scheduler_ptr);
if (scheduler->open () == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%t) Scheduler open failed...\n")),
-1);
}
{
Printer *printer2 = 0;
ACE_NEW_RETURN (printer2,
Printer ("I am printer 2"),
-1);
// Ownership is transferred from the auto_ptr to the strong pointer.
auto_ptr<Printer> a (printer2);
Printer_var r (a);
for (int i = 0; i < n_loops; i++)
// Spawn off the methods, which run in a separate thread as
// active object invocations.
scheduler->print (r);
}
// Close things down.
scheduler->end ();
scheduler->wait ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) Printer instance count is %d, expecting 0\n"),
Printer::instance_count_));
if (Printer::instance_count_ != 0)
return -1;
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return 0;
}
void ImageViewer::displayMatches(QPainter& painter)const
{
QPoint pt1, pt2;
if (siftObj1.keypoints==NULL){
printf("ERROR : Keypoints NULL\n");
exit(-1);
}
if (dispMatch && lastComparison.tab_match!=NULL && !siftObj1.IsEmpty() ){
// Display matches
for (int i=0;i<lastComparison.nb_match;i++) {
pt1.setX(ROUND(lastComparison.tab_match[i].x1));
pt1.setY(ROUND(lastComparison.tab_match[i].y1));
pt2.setX(ROUND(lastComparison.tab_match[i].x2));
pt2.setY(ROUND(lastComparison.tab_match[i].y2 + siftObj1.im->height));
painter.setBrush(Qt::white);
if (lastComparison.tab_match[i].id==0)
painter.setPen(Qt::red); //red for discarded matches
else painter.setPen(Qt::green); //green
painter.drawLine(pt1, pt2);
painter.drawEllipse(pt1, 3, 3);
painter.drawEllipse(pt2, 3, 3);
}
}
#ifdef AAA
//IplImage * im,* imcol;
QSize s;
//QPoint pt1, pt2;
//CvScalar color;
int i,j,im2null=0;
Keypoint k1*=siftObj1->keypoints;
Keypoint k2*=siftObj2->keypoints;
/*Affine transform of the image border*/
if (param.size_m()>0) {
Matrice p1(2,1), p2(2,1), p3(2,1), p4(2,1), transl(2,1);
transl.set_val(0,0,0);
transl.set_val(1,0,im1->height);
p1.set_val(0,0,0);
p1.set_val(1,0,0);
p2.set_val(0,0,im1->width);
p2.set_val(1,0,0);
p3.set_val(0,0,im1->width);
p3.set_val(1,0,im1->height);
p4.set_val(0,0,0);
p4.set_val(1,0,im1->height);
p1=Transform(p1,param)+transl;
p2=Transform(p2,param)+transl;
p3=Transform(p3,param)+transl;
p4=Transform(p4,param)+transl;
color=CV_RGB(0,128,255); //light blue
pt1.x=ROUND(p1.get_val(0,0));
pt1.y=ROUND(p1.get_val(1,0));
pt2.x=ROUND(p2.get_val(0,0));
pt2.y=ROUND(p2.get_val(1,0));
cvLine(imcol, pt1, pt2, color, 1);
pt1.x=ROUND(p2.get_val(0,0));
pt1.y=ROUND(p2.get_val(1,0));
pt2.x=ROUND(p3.get_val(0,0));
pt2.y=ROUND(p3.get_val(1,0));
cvLine(imcol, pt1, pt2, color, 1);
pt1.x=ROUND(p3.get_val(0,0));
pt1.y=ROUND(p3.get_val(1,0));
pt2.x=ROUND(p4.get_val(0,0));
pt2.y=ROUND(p4.get_val(1,0));
cvLine(imcol, pt1, pt2, color, 1);
pt1.x=ROUND(p4.get_val(0,0));
pt1.y=ROUND(p4.get_val(1,0));
pt2.x=ROUND(p1.get_val(0,0));
pt2.y=ROUND(p1.get_val(1,0));
cvLine(imcol, pt1, pt2, color, 1);
/* Draw the border of the object */
CvMemStorage *storage= cvCreateMemStorage (0); /* Memory used by openCV */
int header_size = sizeof( CvContour );
CvSeq *contours;
IplImage* imthres = cvCreateImage(cvSize(im1->width,im1->height),IPL_DEPTH_8U, 1 );
cvCopy( im1, imthres, 0 );
/* First find the contour of a thresholded image*/
cvThreshold(imthres, imthres, border_threshold, 255, CV_THRESH_BINARY );
cvFindContours ( imthres, storage, &contours, header_size, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
/* For each contour found*/
while ( contours != NULL) {
double area=fabs(cvContourArea(contours,CV_WHOLE_SEQ)); // compute area
if ( area > 20) {
for (int i=0;i<contours->total;i++) {
/* Compute transform of contour*/
CvPoint* cvpt=(CvPoint*)cvGetSeqElem( contours, i);
p1.set_val(0,0,cvpt->x);
p1.set_val(1,0,cvpt->y);
p1= Transform(p1,param) + transl;
cvpt->x=ROUND(p1.get_val(0,0));
cvpt->y=ROUND(p1.get_val(1,0));
}
// cvDrawContours( imcol, contours, CV_RGB(0,0,255),CV_RGB(255,0,0),0,2,8);
cvDrawContours( imcol, contours, CV_RGB(0,0,255),CV_RGB(0,0,255),0,2,8);
}
contours = contours->h_next; // ?????
}
free( contours );
cvReleaseMemStorage( &storage );
}
#endif
}
static void tst3() {
enable_trace("nlsat_interval");
reslimit rl;
unsynch_mpq_manager qm;
anum_manager am(rl, qm);
small_object_allocator allocator;
nlsat::interval_set_manager ism(am, allocator);
scoped_anum sqrt2(am), m_sqrt2(am), two(am), m_two(am), three(am), one(am), zero(am);
am.set(two, 2);
am.set(m_two, -2);
am.set(one, 1);
am.root(two, 2, sqrt2);
am.set(m_sqrt2, sqrt2);
am.neg(m_sqrt2);
am.set(three, 3);
nlsat::literal p1(1, false);
nlsat::literal p2(2, false);
nlsat::literal p3(3, false);
nlsat::literal p4(4, false);
nlsat::literal np2(2, true);
nlsat::interval_set_ref s1(ism), s2(ism), s3(ism), s4(ism);
s1 = ism.mk_empty();
std::cout << "s1: " << s1 << "\n";
s2 = ism.mk(true, true, zero, false, false, sqrt2, np2);
std::cout << "s2: " << s2 << "\n";
s3 = ism.mk(false, false, zero, false, false, two, p1);
std::cout << "s3: " << s3 << "\n";
s4 = ism.mk_union(s2, s3);
std::cout << "s4: " << s4 << "\n";
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, zero, false, false, two, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, zero, false, false, two, p1);
s2 = ism.mk(false, false, m_sqrt2, false, false, one, p2);
s3 = ism.mk_union(s1, s2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, one, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, one, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, three, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ]
// s2: [ ... ] [ ... ]
s1 = ism.mk(false, false, m_two, false, false, two, p1);
s2 = ism.mk(false, false, m_sqrt2, false, false, zero, p2);
s3 = ism.mk(false, false, one, false, false, three, p2);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_two, false, false, two, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, two, false, false, three, p1);
tst_interval(s1, s2, 1);
s1 = ism.mk(false, false, m_two, true, false, two, p1);
tst_interval(s1, s2, 2);
s1 = ism.mk(false, false, two, false, false, two, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ] [ ... ]
// s2: [ .. ] [ ... ] [ ... ]
s1 = ism.mk(false, false, m_two, false, false, zero, p1);
s3 = ism.mk(false, false, one, false, false, three, p1);
s1 = ism.mk_union(s1, s3);
s2 = ism.mk(true, true, zero, false, false, m_sqrt2, p2);
tst_interval(s1, s2, 3);
s3 = ism.mk(false, false, one, false, false, sqrt2, p2);
s2 = ism.mk_union(s2, s3);
s3 = ism.mk(false, false, two, true, true, zero, p2);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 4);
// Case
s1 = ism.mk(true, true, zero, false, false, one, p1);
s2 = ism.mk(true, false, one, true, true, zero, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, one, false, false, two, p2);
s3 = ism.mk(false, false, two, true, true, zero, p1);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 3);
}
int main()
{
try
{
symbol k("k"),q("q"),p("p"),p1("p1"),p2("p2"),p3("p3"),ms("ms"),l("l"),s("s"),m1s("m1s"),m2s("m2s"),m3s("m3s");
symbol l1("l1"),l2("l2"),l3("l3"),l4("l4"),t("t"),p4("p4"),p5("p5"),tp("tp"),v1("v1"),v2("v2"),l5("l5");
symbol k1("k1"),k2("k2"),k3("k3"),k4("k4"),k5("k5"),ms1("ms1"),ms2("ms2"),ms3("ms3"),ms4("ms4");
symbol s12("s12"),s23("s23"),s34("s34"),s45("s45"),s51("s51"),s13("s13"),s15("s15");
lst inv_l = lst(
p1*p1 == 0,
p2*p2 == 0,
p3*p3 == 0,
p4*p4 == 0,
p5*p5 == 0,
p1*p2 == s12/2,
p1*p3 == (-s12-s23+s45)/2,
p1*p4 == (-s15+s23-s45)/2,
p1*p5 == s15/2,
p2* p3 ==s23/2,
p2* p4 ==(s15-s23-s34)/2,
p2* p5 ==(-s12-s15+s34)/2,
p3*p4 == s34/2,
p3*p5 == (s12-s34-s45)/2,
p4*p5 == s45/2);
#define topo 2
#if topo==1
/* 1+eps normalization
FRESULT for parameters: {s12==-2,s23==-3,s34==-4,s45==-5,s15==-6,ms==1}
FRESULT anl : = -0.010071141398715986043
FRESULT num: = -0.010071141398715986043
eps^0 term: -0.010071141398715986043 +/- 7.5387750593540493467E-5
*/
/* Euler renormalization
FRESULT for parameters: {s12==-2,s23==-3,s34==-4,s45==-5,s15==-6,ms==1}
FRESULT anl : = 0.020204464861409441711
FRESULT num: = 0.020204464861409441711
eps^0 term: 0.020204464861409441711 +/- 2.9955911201888832611E-4
*/
RoMB_loop_by_loop pent(lst(k1),lst(-pow(p1 + k1,2)+ms,-pow(p1 + p2 + k1,2)+ms,
-pow(p1 + p2 + p3 + k1,2)+ms,-pow(p1 + p2 + p3 + p4 + k1,2)+ms,
-pow(k1,2)+ms),
inv_l,
lst(1,1,1,1,1),false);
pent.integrate_map(lst(s12==-2,s23==-3,s34==-4,s45==-5,s15==-6,ms==1));
#elif topo==2
// M=0 with factor tgamma(1-eps)^2/tgamma(1-2eps)
/* PJfry
* 1/eps^-2 :(-0.111111,0)
* 1/eps^-1 :(0.0856421,0)
* 1/eps^0 :(0.0513422,0) -3.28987
*/
RoMB_loop_by_loop pent(lst(k2,k1),lst(-pow(k1,2),-pow(k1 - k2 ,2),
-pow(k1+p1 + p2,2),-pow(k1 - p4 - p5,2),
-pow(k1-p5,2),-pow(k2,2),-pow(k2+p1,2),-pow(k2+p1+p2,2)),
inv_l,
lst(1,1,1,1,1,1,1,1),true);
pent.integrate_map(lst(s12==-2,s23==-4,s34==-5,s45==-6,s15==-0.5,ms==1),0);
/*
FRESULT for parameters: {s12==-2,s23==-4,s34==-5,s45==-6,s15==-0.5,ms==1}
FRESULT anl : = 400.22174334151294225-(0.24583333333333333332)*log(4)^2*log(5)*log(2)-(3.3881317890172013563E-21)*Euler*log(5)^2+(7.284483346386982916E-20)*Euler*log(5)*log(6)*log(2)-(0.11210570324758033243)*log(4)*log(6)-(2.1006417091906648409E-19)*Euler*log(5)*log(6)-(8.470329472543003391E-21)*Euler+(1.4484263398048535798E-19)*Euler*log(5)^2*log(2)+(0.34079736377530644382)*log(4)*log(6)*log(2)-(0.17039868188765322194)*log(4)^2*log(2)+eps^(-2)*(-1.3333035413347974529-(0.12916666666666666666)*log(4)*log(6)+(1.9274705288631189937E-20)*Euler+(3.3730734255104582391E-20)*Euler*log(6)+(0.121354166666666666677)*Pi^2+(0.014440566261665527283)*log(4)+(0.054166666666666666667)*log(5)*log(6)+(3.08395284618099039E-19)*Euler^2+(0.24693368307448051649)*log(5)-(1.2046690805394493711E-20)*Euler*log(4)-(0.045833333333333333334)*log(4)*log(5)+(0.16666666666666666667)*log(2)^2-(0.0086643397569993163535)*log(6)-(0.025)*log(6)*log(2)-(1.9274705288631189937E-20)*Euler*log(5)+(0.0625)*log(6)^2-(0.27725887222397812377)*log(2)-(0.4)*log(5)*log(2)+(0.07708333333333333334)*log(4)^2+(0.178125)*log(5)^2+(0.029166666666666666667)*log(4)*log(2)+(7.709882115452475975E-20)*Euler*log(2))+(2.2022856628611808816E-20)*Euler*log(4)^3-(4.336808689942017736E-19)*Euler^2*log(2)-(0.066426604803661425496)*log(4)*log(5)^2+(0.014236111111111111113)*log(4)^4+(2.710505431213761085E-20)*Euler*log(6)-(1.1011428314305904408E-19)*Euler*log(6)*Pi^2-(0.25763888888888888888)*log(5)^3*log(2)+(0.09861111111111111112)*log(5)*log(6)^3+(0.07797905781299384727)*log(6)*log(2)^2+(2.168404344971008868E-19)*Euler*log(4)*log(5)-(3.3881317890172013563E-20)*Euler*log(4)^2+(0.058333333333333333313)*log(4)*log(5)^2*log(2)+(1.4696021634862110883E-19)*Euler*log(6)*log(2)-(1.2493735972000930001E-20)*Euler*log(5)^3-(0.32346868426130781108)*log(4)*log(5)*log(6)+(1.8223154162344101082-(1.9274705288631189937E-20)*Euler*log(5)^2-(0.17906302164465253826)*log(4)*log(6)-(3.252606517456513302E-20)*Euler+(0.275)*log(4)*log(6)*log(2)-(0.14166666666666666667)*log(4)^2*log(2)-(4.9030031577955589404E-19)*Euler^2*log(2)-(0.029166666666666666667)*log(4)*log(5)^2-(4.336808689942017736E-20)*Euler*log(6)+(0.03125)*log(6)*log(2)^2-(2.4093381610788987422E-20)*Euler*log(4)*log(5)+(2.379221434065412508E-20)*Euler*log(6)*log(2)-(0.25833333333333333333)*log(4)*log(5)*log(6)+(0.17641558449668052497)*Pi^2+(0.12916666666666666666)*log(5)*log(6)^2+(0.018016988021932553424)*log(4)-(0.35625)*log(5)^2*log(2)+(0.04043358553266347639)*log(5)*log(6)+(3.8549410577262379875E-20)*Euler*log(4)*log(6)+(3.2766998990673022894E-19)*Euler^2-(0.64791666666666666673)*zeta(3)-(0.11319444444444444446)*log(2)^3+(0.18467412722480867264)*log(5)+(0.09756944444444444444)*log(6)*Pi^2+(4.8186763221577974843E-21)*Euler*log(4)-(0.040433585532663476392)*log(4)*log(5)+(0.27725887222397812372)*log(2)^2-(0.018016988021932553429)*log(6)+(1.541976423090495195E-19)*Euler^3-(0.07509094456066074186)*log(6)*log(2)+(3.1321396094025683648E-20)*Euler*log(5)-(0.2375)*log(4)*log(6)^2+(0.08953151082232626913)*log(6)^2-(2.168404344971008868E-20)*Euler*log(2)^2+(0.12083333333333333333)*log(4)^2*log(5)-(0.14375)*log(6)^2*log(2)-(0.108333333333333333334)*log(5)*log(6)*log(2)-(0.17116138620835925754)*log(2)+(2.0238440553062749435E-19)*Euler^2*log(5)-(0.025)*log(4)*log(2)^2-(0.22395833333333333336)*log(2)*Pi^2+(0.23229166666666666667)*log(5)*Pi^2+(0.029166666666666666667)*log(5)^2*log(6)-(2.4093381610788987422E-20)*Euler*log(4)*log(2)-(0.49386736614896103298)*log(5)*log(2)+(0.08541666666666666667)*log(6)^3+(0.08375528431766005821)*log(4)^2+(3.8549410577262379875E-20)*Euler*Pi^2+(0.128125)*log(5)^3+(0.108333333333333333334)*log(4)*log(5)*log(2)+(0.4)*log(5)*log(2)^2-(0.09409722222222222222)*log(4)*Pi^2+(7.709882115452475975E-20)*Euler*log(5)*log(2)+(0.26642844752772897827)*log(5)^2+(0.0750909445606607419)*log(4)*log(2)+(0.22916666666666666667)*log(4)^2*log(6)-(0.080555555555555555553)*log(4)^3+(1.1594939900192200198E-19)*Euler*log(2))*eps^(-1)-(3.1509625637859972613E-19)*Euler^2*log(5)*log(2)-(1.5246593050577406103E-20)*Euler^2*Pi^2+(0.44166666666666666666)*zeta(3)*log(6)+(0.12361655670603724154)*Pi^2+(0.062586805555555555545)*log(5)^4-(2.5410988417629010172E-20)*Euler*log(4)*log(6)^2-(0.020138888888888888871)*log(6)*log(2)^3+(0.164622455382987011)*log(5)*log(6)^2+(0.3583333333333333334)*log(5)^2*log(2)^2-(0.22152777777777777779)*log(4)*log(6)*Pi^2+(0.10729166666666666671)*log(4)^2*Pi^2-(0.031944444444444444437)*log(4)*log(5)^3+(0.0041628081498616184988)*log(4)-(9.5714723039735938315E-20)*Euler*log(4)*log(5)*log(2)+(3.9954857837891737475E-20)*Euler*log(4)^2*log(2)-(0.53574500830779106205)*log(5)^2*log(2)-(2.5199230180815435087E-19)*Euler*zeta(3)+(0.048045301391820142482)*log(5)*log(6)-(4.7433845046240818988E-20)*Euler*log(4)*log(6)-(0.06249999999999999996)*log(5)^2*log(6)*log(2)+(6.168313523040288406E-19)*Euler^2-(0.9097222222222222222)*zeta(3)*log(5)-(1.0464597017620285435)*zeta(3)-(4.539037806098981942E-19)*Euler^3*log(2)-(0.18580195256676311766)*log(2)^3-(2.710505431213761085E-20)*Euler*log(6)^3+(0.08337179655695074824)*log(5)+(0.12755833531137882431)*log(6)*Pi^2+(2.2022856628611808816E-20)*Euler*log(4)*log(5)^2-(1.3552527156068805425E-20)*Euler*log(4)+(0.012326388888888888894)*log(6)^4-(0.4125)*log(4)*zeta(3)-(0.30416666666666666667)*log(4)*log(5)*log(6)^2+(0.49166666666666666665)*log(4)*log(5)*log(6)*log(2)-(0.066666666666666666677)*log(4)*log(6)^3+(4.7433845046240818988E-20)*Euler*log(6)*log(2)^2+(0.14305555555555555555)*log(4)^3*log(2)-(0.046043413833827636543)*log(4)*log(5)-(2.168404344971008868E-19)*Euler*log(6)^2+(0.1721623299873555105)*log(2)^2-(0.0037002739109881053319)*log(6)-(2.3039296165316969223E-19)*Euler^2*log(2)^2+(1.0062751413381088028E-18)*Euler^3-(2.168404344971008868E-19)*Euler^2*log(4)*log(2)-(0.25)*log(5)*log(6)^2*log(2)+(0.20505604272398455968-(2.8912057932946784908E-20)*Euler+(0.00625)*log(4)+(0.19583333333333333331)*log(5)-(0.018750000000000000007)*log(6)-(0.16875)*log(2))*eps^(-3)-(0.030028313369887589065)*log(6)*log(2)-(0.275)*log(4)*log(6)*log(2)^2+(0.13125)*log(4)^2*log(2)^2+(4.0657581468206416275E-20)*Euler*log(5)*log(6)^2-(8.131516293641283255E-20)*Euler*log(5)-(0.2570420794576463856)*log(4)*log(6)^2-(0.47430555555555555555)*log(5)*log(2)*Pi^2+(0.2350694444444444444)*log(5)^2*Pi^2+(0.22569444444444444447)*log(2)^2*Pi^2+(0.05705379540278641918)*log(6)^2+(1.5814418841144177812E-20)*Euler*log(2)^2+(0.16173434213065390554)*log(4)^2*log(5)+(1.5585406229479126239E-19)*Euler^2*log(6)^2-(0.17328679513998632736)*log(6)^2*log(2)+(7.030373462210692814E-20)*Euler*log(4)*log(6)*log(2)-(0.086643397569993163665)*log(5)*log(6)*log(2)-(0.08580010131103669233)*log(2)+(2.2700482986415249087E-19)*Euler^2*log(5)+(0.09999999999999999998)*log(4)^2*log(6)^2-(0.07509094456066074196)*log(4)*log(2)^2-(6.7762635780344027125E-20)*Euler*log(5)*log(2)^2-(0.32876355855725183764)*log(2)*Pi^2+(8.1950437646853557805E-20)*Euler^4-(1.1858461261560204747E-20)*Euler*log(4)*Pi^2+(0.3258754453049187323)*log(5)*Pi^2+(0.06931471805599453092)*log(5)^2*log(6)+(3.642241673193491458E-20)*Euler*log(4)^2*log(6)-(1.7194768829262296883E-19)*Euler*log(4)*log(2)-(0.37135014200760985115)*log(5)*log(2)+(1.1011428314305904408E-19)*Euler*log(2)^3+(0.08375528431766005824)*log(6)^3+(1.8431436932253575378E-18)*Euler^3*log(6)+(0.056423611111111111103)*log(2)^4-(4.0826988057657276343E-19)*Euler^2*log(4)+(0.112499999999999999984)*log(6)^2*Pi^2+(0.18402777777777777775)*log(5)*log(6)*Pi^2-(0.061111111111111111102)*log(4)^3*log(6)-(0.108333333333333333294)*log(4)*log(5)*log(2)^2+(0.020833333333333333319)*log(4)*log(2)^3-(8.131516293641283255E-20)*Euler^2*log(4)^2-(6.7762635780344027125E-21)*Euler*log(4)^2*log(5)+(0.056052851623790166215)*log(4)^2-(2.6893296075324035765E-19)*Euler^2*log(5)*log(6)-(1.626303258728256651E-19)*Euler^3*log(5)+(4.2986922073155742208E-20)*Euler*Pi^2+(0.66666666666666666706)*zeta(3)*log(2)-(0.4083333333333333333)*log(4)^2*log(6)*log(2)+(0.17352747124434741951)*log(5)^3-(0.23333333333333333333)*log(4)*log(5)^2*log(6)+(0.080867171065326952724)*log(4)*log(5)*log(2)-(1.6940658945086006781E-20)*Euler*log(6)^2*log(2)-(0.13125)*log(6)^3*log(2)+(0.49675547940129413833)*log(5)*log(2)^2-(1.3552527156068805425E-20)*Euler*log(4)*log(2)^2+(0.11874999999999999999)*log(5)^2*log(6)^2+(0.140625)*eps^(-4)+(3.8963515573697815597E-20)*Euler*log(5)*Pi^2-(0.10416666666666666666)*log(4)^3*log(5)-(0.1208194043892682449)*log(4)*Pi^2-(7.284483346386982916E-20)*Euler*log(2)*Pi^2+(8.131516293641283255E-20)*Euler*log(5)*log(2)+(0.18042011616407459749)*log(5)^2+(0.40833333333333333333)*log(4)*log(6)^2*log(2)+(0.028026425811895083111)*log(4)*log(2)+(1.6940658945086006781E-19)*Euler^2*log(5)^2+(0.26570641921464570196)*log(4)^2*log(6)-(1.0164395367051604069E-20)*Euler*log(5)^2*log(6)+(1.084202172485504434E-19)*Euler^2*log(6)*log(2)+(0.31666666666666666664)*log(4)^2*log(5)*log(6)+(1.176528763736223171E-18)*Euler^3*log(4)+(3.0323779511703952139E-19)*Euler^2*log(4)*log(5)-(0.19861111111111111116)*log(6)*log(2)*Pi^2-(0.08760610198743753216)*log(4)^3+(0.19513888888888888883)*log(4)*log(2)*Pi^2-(0.17430555555555555551)*log(4)*log(5)*Pi^2+(0.11666666666666666666)*log(4)^2*log(5)^2-(1.084202172485504434E-19)*Euler^2*log(6)+(1.3044307387716225222E-19)*Euler*log(2)+(0.11249999999999999996)*log(5)*log(6)*log(2)^2-(0.26805555555555555557)*log(5)*log(2)^3+(0.13645833333333333334)*log(6)^2*log(2)^2+(0.09795428240740740744)*Pi^4+(0.033333333333333333352)*log(5)^3*log(6)
FRESULT num: = 415.68016240483728552+(5.9729895535000929493)*eps^(-1)+(0.24826188972445505333)*eps^(-2)+(0.37833789689847839715)*eps^(-3)+(0.140625)*eps^(-4)
eps^-4 term: 0.140625 +/- 0
eps^-3 term: 0.20505604272398455968-(2.8912057932946784908E-20)*Euler+(0.00625)*log(4)+(0.19583333333333333331)*log(5)-(0.018750000000000000007)*log(6)-(0.16875)*log(2) +/- 5.7595906625256782043E-11
eps^-2 term: -1.3333035413347974529-(0.12916666666666666666)*log(4)*log(6)+(1.9274705288631189937E-20)*Euler+(3.3730734255104582391E-20)*Euler*log(6)+(0.121354166666666666677)*Pi^2+(0.014440566261665527283)*log(4)+(0.054166666666666666667)*log(5)*log(6)+(3.08395284618099039E-19)*Euler^2+(0.24693368307448051649)*log(5)-(1.2046690805394493711E-20)*Euler*log(4)-(0.045833333333333333334)*log(4)*log(5)+(0.16666666666666666667)*log(2)^2-(0.0086643397569993163535)*log(6)-(0.025)*log(6)*log(2)-(1.9274705288631189937E-20)*Euler*log(5)+(0.0625)*log(6)^2-(0.27725887222397812377)*log(2)-(0.4)*log(5)*log(2)+(0.07708333333333333334)*log(4)^2+(0.178125)*log(5)^2+(0.029166666666666666667)*log(4)*log(2)+(7.709882115452475975E-20)*Euler*log(2) +/- 2.38034674326464079E-6
eps^-1 term: 1.8223154162344101082-(1.9274705288631189937E-20)*Euler*log(5)^2-(0.17906302164465253826)*log(4)*log(6)-(3.252606517456513302E-20)*Euler+(0.275)*log(4)*log(6)*log(2)-(0.14166666666666666667)*log(4)^2*log(2)-(4.9030031577955589404E-19)*Euler^2*log(2)-(0.029166666666666666667)*log(4)*log(5)^2-(4.336808689942017736E-20)*Euler*log(6)+(0.03125)*log(6)*log(2)^2-(2.4093381610788987422E-20)*Euler*log(4)*log(5)+(2.379221434065412508E-20)*Euler*log(6)*log(2)-(0.25833333333333333333)*log(4)*log(5)*log(6)+(0.17641558449668052497)*Pi^2+(0.12916666666666666666)*log(5)*log(6)^2+(0.018016988021932553424)*log(4)-(0.35625)*log(5)^2*log(2)+(0.04043358553266347639)*log(5)*log(6)+(3.8549410577262379875E-20)*Euler*log(4)*log(6)+(3.2766998990673022894E-19)*Euler^2-(0.64791666666666666673)*zeta(3)-(0.11319444444444444446)*log(2)^3+(0.18467412722480867264)*log(5)+(0.09756944444444444444)*log(6)*Pi^2+(4.8186763221577974843E-21)*Euler*log(4)-(0.040433585532663476392)*log(4)*log(5)+(0.27725887222397812372)*log(2)^2-(0.018016988021932553429)*log(6)+(1.541976423090495195E-19)*Euler^3-(0.07509094456066074186)*log(6)*log(2)+(3.1321396094025683648E-20)*Euler*log(5)-(0.2375)*log(4)*log(6)^2+(0.08953151082232626913)*log(6)^2-(2.168404344971008868E-20)*Euler*log(2)^2+(0.12083333333333333333)*log(4)^2*log(5)-(0.14375)*log(6)^2*log(2)-(0.108333333333333333334)*log(5)*log(6)*log(2)-(0.17116138620835925754)*log(2)+(2.0238440553062749435E-19)*Euler^2*log(5)-(0.025)*log(4)*log(2)^2-(0.22395833333333333336)*log(2)*Pi^2+(0.23229166666666666667)*log(5)*Pi^2+(0.029166666666666666667)*log(5)^2*log(6)-(2.4093381610788987422E-20)*Euler*log(4)*log(2)-(0.49386736614896103298)*log(5)*log(2)+(0.08541666666666666667)*log(6)^3+(0.08375528431766005821)*log(4)^2+(3.8549410577262379875E-20)*Euler*Pi^2+(0.128125)*log(5)^3+(0.108333333333333333334)*log(4)*log(5)*log(2)+(0.4)*log(5)*log(2)^2-(0.09409722222222222222)*log(4)*Pi^2+(7.709882115452475975E-20)*Euler*log(5)*log(2)+(0.26642844752772897827)*log(5)^2+(0.0750909445606607419)*log(4)*log(2)+(0.22916666666666666667)*log(4)^2*log(6)-(0.080555555555555555553)*log(4)^3+(1.1594939900192200198E-19)*Euler*log(2) +/- 4.3702165714070080051E-4
eps^0 term: 400.22174334151294225-(0.24583333333333333332)*log(4)^2*log(5)*log(2)-(3.3881317890172013563E-21)*Euler*log(5)^2+(7.284483346386982916E-20)*Euler*log(5)*log(6)*log(2)-(0.11210570324758033243)*log(4)*log(6)-(2.1006417091906648409E-19)*Euler*log(5)*log(6)-(8.470329472543003391E-21)*Euler+(1.4484263398048535798E-19)*Euler*log(5)^2*log(2)+(0.34079736377530644382)*log(4)*log(6)*log(2)-(0.17039868188765322194)*log(4)^2*log(2)+(2.2022856628611808816E-20)*Euler*log(4)^3-(4.336808689942017736E-19)*Euler^2*log(2)-(0.066426604803661425496)*log(4)*log(5)^2+(0.014236111111111111113)*log(4)^4+(2.710505431213761085E-20)*Euler*log(6)-(1.1011428314305904408E-19)*Euler*log(6)*Pi^2-(0.25763888888888888888)*log(5)^3*log(2)+(0.09861111111111111112)*log(5)*log(6)^3+(0.07797905781299384727)*log(6)*log(2)^2+(2.168404344971008868E-19)*Euler*log(4)*log(5)-(3.3881317890172013563E-20)*Euler*log(4)^2+(0.058333333333333333313)*log(4)*log(5)^2*log(2)+(1.4696021634862110883E-19)*Euler*log(6)*log(2)-(1.2493735972000930001E-20)*Euler*log(5)^3-(0.32346868426130781108)*log(4)*log(5)*log(6)-(3.1509625637859972613E-19)*Euler^2*log(5)*log(2)-(1.5246593050577406103E-20)*Euler^2*Pi^2+(0.44166666666666666666)*zeta(3)*log(6)+(0.12361655670603724154)*Pi^2+(0.062586805555555555545)*log(5)^4-(2.5410988417629010172E-20)*Euler*log(4)*log(6)^2-(0.020138888888888888871)*log(6)*log(2)^3+(0.164622455382987011)*log(5)*log(6)^2+(0.3583333333333333334)*log(5)^2*log(2)^2-(0.22152777777777777779)*log(4)*log(6)*Pi^2+(0.10729166666666666671)*log(4)^2*Pi^2-(0.031944444444444444437)*log(4)*log(5)^3+(0.0041628081498616184988)*log(4)-(9.5714723039735938315E-20)*Euler*log(4)*log(5)*log(2)+(3.9954857837891737475E-20)*Euler*log(4)^2*log(2)-(0.53574500830779106205)*log(5)^2*log(2)-(2.5199230180815435087E-19)*Euler*zeta(3)+(0.048045301391820142482)*log(5)*log(6)-(4.7433845046240818988E-20)*Euler*log(4)*log(6)-(0.06249999999999999996)*log(5)^2*log(6)*log(2)+(6.168313523040288406E-19)*Euler^2-(0.9097222222222222222)*zeta(3)*log(5)-(1.0464597017620285435)*zeta(3)-(4.539037806098981942E-19)*Euler^3*log(2)-(0.18580195256676311766)*log(2)^3-(2.710505431213761085E-20)*Euler*log(6)^3+(0.08337179655695074824)*log(5)+(0.12755833531137882431)*log(6)*Pi^2+(2.2022856628611808816E-20)*Euler*log(4)*log(5)^2-(1.3552527156068805425E-20)*Euler*log(4)+(0.012326388888888888894)*log(6)^4-(0.4125)*log(4)*zeta(3)-(0.30416666666666666667)*log(4)*log(5)*log(6)^2+(0.49166666666666666665)*log(4)*log(5)*log(6)*log(2)-(0.066666666666666666677)*log(4)*log(6)^3+(4.7433845046240818988E-20)*Euler*log(6)*log(2)^2+(0.14305555555555555555)*log(4)^3*log(2)-(0.046043413833827636543)*log(4)*log(5)-(2.168404344971008868E-19)*Euler*log(6)^2+(0.1721623299873555105)*log(2)^2-(0.0037002739109881053319)*log(6)-(2.3039296165316969223E-19)*Euler^2*log(2)^2+(1.0062751413381088028E-18)*Euler^3-(2.168404344971008868E-19)*Euler^2*log(4)*log(2)-(0.25)*log(5)*log(6)^2*log(2)-(0.030028313369887589065)*log(6)*log(2)-(0.275)*log(4)*log(6)*log(2)^2+(0.13125)*log(4)^2*log(2)^2+(4.0657581468206416275E-20)*Euler*log(5)*log(6)^2-(8.131516293641283255E-20)*Euler*log(5)-(0.2570420794576463856)*log(4)*log(6)^2-(0.47430555555555555555)*log(5)*log(2)*Pi^2+(0.2350694444444444444)*log(5)^2*Pi^2+(0.22569444444444444447)*log(2)^2*Pi^2+(0.05705379540278641918)*log(6)^2+(1.5814418841144177812E-20)*Euler*log(2)^2+(0.16173434213065390554)*log(4)^2*log(5)+(1.5585406229479126239E-19)*Euler^2*log(6)^2-(0.17328679513998632736)*log(6)^2*log(2)+(7.030373462210692814E-20)*Euler*log(4)*log(6)*log(2)-(0.086643397569993163665)*log(5)*log(6)*log(2)-(0.08580010131103669233)*log(2)+(2.2700482986415249087E-19)*Euler^2*log(5)+(0.09999999999999999998)*log(4)^2*log(6)^2-(0.07509094456066074196)*log(4)*log(2)^2-(6.7762635780344027125E-20)*Euler*log(5)*log(2)^2-(0.32876355855725183764)*log(2)*Pi^2+(8.1950437646853557805E-20)*Euler^4-(1.1858461261560204747E-20)*Euler*log(4)*Pi^2+(0.3258754453049187323)*log(5)*Pi^2+(0.06931471805599453092)*log(5)^2*log(6)+(3.642241673193491458E-20)*Euler*log(4)^2*log(6)-(1.7194768829262296883E-19)*Euler*log(4)*log(2)-(0.37135014200760985115)*log(5)*log(2)+(1.1011428314305904408E-19)*Euler*log(2)^3+(0.08375528431766005824)*log(6)^3+(1.8431436932253575378E-18)*Euler^3*log(6)+(0.056423611111111111103)*log(2)^4-(4.0826988057657276343E-19)*Euler^2*log(4)+(0.112499999999999999984)*log(6)^2*Pi^2+(0.18402777777777777775)*log(5)*log(6)*Pi^2-(0.061111111111111111102)*log(4)^3*log(6)-(0.108333333333333333294)*log(4)*log(5)*log(2)^2+(0.020833333333333333319)*log(4)*log(2)^3-(8.131516293641283255E-20)*Euler^2*log(4)^2-(6.7762635780344027125E-21)*Euler*log(4)^2*log(5)+(0.056052851623790166215)*log(4)^2-(2.6893296075324035765E-19)*Euler^2*log(5)*log(6)-(1.626303258728256651E-19)*Euler^3*log(5)+(4.2986922073155742208E-20)*Euler*Pi^2+(0.66666666666666666706)*zeta(3)*log(2)-(0.4083333333333333333)*log(4)^2*log(6)*log(2)+(0.17352747124434741951)*log(5)^3-(0.23333333333333333333)*log(4)*log(5)^2*log(6)+(0.080867171065326952724)*log(4)*log(5)*log(2)-(1.6940658945086006781E-20)*Euler*log(6)^2*log(2)-(0.13125)*log(6)^3*log(2)+(0.49675547940129413833)*log(5)*log(2)^2-(1.3552527156068805425E-20)*Euler*log(4)*log(2)^2+(0.11874999999999999999)*log(5)^2*log(6)^2+(3.8963515573697815597E-20)*Euler*log(5)*Pi^2-(0.10416666666666666666)*log(4)^3*log(5)-(0.1208194043892682449)*log(4)*Pi^2-(7.284483346386982916E-20)*Euler*log(2)*Pi^2+(8.131516293641283255E-20)*Euler*log(5)*log(2)+(0.18042011616407459749)*log(5)^2+(0.40833333333333333333)*log(4)*log(6)^2*log(2)+(0.028026425811895083111)*log(4)*log(2)+(1.6940658945086006781E-19)*Euler^2*log(5)^2+(0.26570641921464570196)*log(4)^2*log(6)-(1.0164395367051604069E-20)*Euler*log(5)^2*log(6)+(1.084202172485504434E-19)*Euler^2*log(6)*log(2)+(0.31666666666666666664)*log(4)^2*log(5)*log(6)+(1.176528763736223171E-18)*Euler^3*log(4)+(3.0323779511703952139E-19)*Euler^2*log(4)*log(5)-(0.19861111111111111116)*log(6)*log(2)*Pi^2-(0.08760610198743753216)*log(4)^3+(0.19513888888888888883)*log(4)*log(2)*Pi^2-(0.17430555555555555551)*log(4)*log(5)*Pi^2+(0.11666666666666666666)*log(4)^2*log(5)^2-(1.084202172485504434E-19)*Euler^2*log(6)+(1.3044307387716225222E-19)*Euler*log(2)+(0.11249999999999999996)*log(5)*log(6)*log(2)^2-(0.26805555555555555557)*log(5)*log(2)^3+(0.13645833333333333334)*log(6)^2*log(2)^2+(0.09795428240740740744)*Pi^4+(0.033333333333333333352)*log(5)^3*log(6) +/- 0.010448924004628639662
*/
#endif
}
catch(std::exception &p)
{
std::cerr<<"******************************************************************"<<endl;
std::cerr<<" >>>ERROR: "<<p.what()<<endl;
std::cerr<<"******************************************************************"<<endl;
return 1;
}
return 0;
}
