bool calculateF(Pair ab, Pair de, Pair pq, int c, Vert &vertices,
Point &result) {
Pair bc = std::make_pair(ab.second, c);
Pair dc = std::make_pair(de.first, c);
if (ifParallel(bc, pq, vertices)) {
return false;
}
Point bcpq = calculateIntersection(bc, pq, vertices);
if (ifParallel(dc, pq, vertices)) {
return false;
}
Point dcpq = calculateIntersection(dc, pq, vertices);
Point e = vertices[de.second];
Point a = vertices[ab.first];
if (ifParallel(bcpq, e, dcpq, a)) {
return false;
}
result = calculateIntersection(bcpq, e, dcpq, a);
return true;
}
bool calculateLineCoordinates(bool inside, int x, int y, bool pinside, int px, int py, int leftX, int rightX,
int bottomY, int topY, std::vector<int_pair>& coordinates) {
bool lineEnded = false;
int_pair b(x, y);
if (pinside) {
if (!inside) {
bool is = calculateIntersection(x, y, px, py, leftX, rightX, bottomY, topY, b);
if (!is) {
b.first = px;
b.second = py;
}
coordinates.push_back(b);
lineEnded = true;
} else {
coordinates.push_back(b);
}
} else {
bool is = calculateIntersection(x, y, px, py, leftX, rightX, bottomY, topY, b);
if (inside) {
// assert is != -1;
coordinates.push_back(b);
int_pair n(x, y);
coordinates.push_back(n);
} else if (is) {
coordinates.push_back(b);
calculateIntersection(x, y, b.first, b.second, leftX, rightX, bottomY, topY, b);
coordinates.push_back(b);
lineEnded = true;
}
}
return lineEnded;
}
RigEclipseWellLogExtractor::RigEclipseWellLogExtractor(const RigEclipseCaseData* aCase,
const RigWellPath* wellpath,
const std::string& wellCaseErrorMsgName)
: RigWellLogExtractor(wellpath, wellCaseErrorMsgName)
, m_caseData(aCase)
{
calculateIntersection();
}
Coordinate
calculateIntersection (const Coordinate& p0, const Coordinate& p1,
const Coordinate& p2, const Coordinate& p3)
{
double u0 = p1.x - p0.x;
double v0 = p1.y - p0.y;
double u1 = p3.x - p2.x;
double v1 = p3.y - p2.y;
double a1 = v0 / u0;
double b1 = p0.y - a1 * p0.x;
double a2 = v1 / u1;
double b2 = p2.y - a2 * p2.x;
return calculateIntersection (a1, b1, a2, b2);
}
void MouseAttack::setMouseCoords(int mouseX, int mouseY)
{
float x = (2.0f * mouseX) / ContextWindow::getCurrent().getWidth() - 1.0f;
float y = 1.0f - (2.0f * mouseY) / ContextWindow::getCurrent().getHeight();
float z = 1.0f;
//std::cout << x << " " << y << std::endl;
glm::vec3 screenPosition = glm::vec3(x, y,z);
if (camera != nullptr)
{
glm::vec4 ray_clip = glm::vec4(screenPosition.x, screenPosition.y, -1.0, 1.0);
glm::vec4 ray_eye = glm::inverse(camera->getProjection()) * ray_clip;
ray_eye = glm::vec4(ray_eye.x, ray_eye.y, -1.0f, 0.0f);
glm::vec3 ray_world = glm::vec3(glm::inverse(camera->getView()) * ray_eye);
ray_world = glm::normalize(ray_world);
this->rayWorld = ray_world;
calculateIntersection(ray_world, camera->getPosition());
}
//std::cout << ray_world.x << " " << ray_world.y << " " << ray_world.z << std::endl;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigGeoMechWellLogExtractor::RigGeoMechWellLogExtractor(RigGeoMechCaseData* aCase, const RigWellPath* wellpath, const std::string& wellCaseErrorMsgName)
:m_caseData(aCase), RigWellLogExtractor(wellpath, wellCaseErrorMsgName)
{
calculateIntersection();
}
void IsoSurfaceThread::run()
{
int numThreads = GLFunctions::idealThreadCount;
int chunkSize = m_scalarField->size() / numThreads;
int begin = m_id * chunkSize;
int end = m_id * chunkSize + chunkSize;
if ( m_id == numThreads - 1 )
{
end = m_scalarField->size() - ( ( m_nX + 1 ) * ( m_nY + 1 ) );
}
int x;
int y;
int z;
// Generate isosurface.
for ( int k = begin; k < end; ++k )
{
getXYZ( k, x, y, z );
if ( x == m_nX ) continue;
if ( y == m_nY ) continue;
// Calculate table lookup index from those
// vertices which are below the isolevel.
unsigned int tableIndex = 0;
if ( m_scalarField->at( z * m_nPointsInSlice + y * m_nPointsInXDirection + x ) < m_isoLevel )
tableIndex |= 1;
if ( m_scalarField->at( z * m_nPointsInSlice + ( y + 1 ) * m_nPointsInXDirection + x ) < m_isoLevel )
tableIndex |= 2;
if ( m_scalarField->at( z * m_nPointsInSlice + ( y + 1 ) * m_nPointsInXDirection + ( x + 1 ) ) < m_isoLevel )
tableIndex |= 4;
if ( m_scalarField->at( z * m_nPointsInSlice + y * m_nPointsInXDirection + ( x + 1 ) ) < m_isoLevel )
tableIndex |= 8;
if ( m_scalarField->at( ( z + 1 ) * m_nPointsInSlice + y * m_nPointsInXDirection + x ) < m_isoLevel )
tableIndex |= 16;
if ( m_scalarField->at( ( z + 1 ) * m_nPointsInSlice + ( y + 1 ) * m_nPointsInXDirection + x ) < m_isoLevel )
tableIndex |= 32;
if ( m_scalarField->at( ( z + 1 ) * m_nPointsInSlice + ( y + 1 ) * m_nPointsInXDirection + ( x + 1 ) ) < m_isoLevel )
tableIndex |= 64;
if ( m_scalarField->at( ( z + 1 ) * m_nPointsInSlice + y * m_nPointsInXDirection + ( x + 1 ) ) < m_isoLevel )
tableIndex |= 128;
// Now create a triangulation of the isosurface in this
// cell.
if ( edgeTable[ tableIndex ] != 0 )
{
if ( edgeTable[ tableIndex ] & 8 )
{
POINT3DID pt = calculateIntersection( x, y, z, 3 );
unsigned int id = getEdgeID( x, y, z, 3 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( edgeTable[ tableIndex ] & 1 )
{
POINT3DID pt = calculateIntersection( x, y, z, 0 );
unsigned int id = getEdgeID( x, y, z, 0 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( edgeTable[ tableIndex ] & 256 )
{
POINT3DID pt = calculateIntersection( x, y, z, 8 );
unsigned int id = getEdgeID( x, y, z, 8 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( x == m_nX - 1 )
{
if ( edgeTable[ tableIndex ] & 4 )
{
POINT3DID pt = calculateIntersection( x, y, z, 2 );
unsigned int id = getEdgeID( x, y, z, 2 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( edgeTable[ tableIndex ] & 2048 )
{
POINT3DID pt = calculateIntersection( x, y, z, 11 );
unsigned int id = getEdgeID( x, y, z, 11 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
}
if ( y == m_nY - 1 )
{
if ( edgeTable[ tableIndex ] & 2 )
{
POINT3DID pt = calculateIntersection( x, y, z, 1 );
unsigned int id = getEdgeID( x, y, z, 1 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( edgeTable[ tableIndex ] & 512 )
{
POINT3DID pt = calculateIntersection( x, y, z, 9 );
unsigned int id = getEdgeID( x, y, z, 9 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
}
if ( z == m_nZ - 1 )
{
if ( edgeTable[ tableIndex ] & 16 )
{
POINT3DID pt = calculateIntersection( x, y, z, 4 );
unsigned int id = getEdgeID( x, y, z, 4 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( edgeTable[ tableIndex ] & 128 )
{
POINT3DID pt = calculateIntersection( x, y, z, 7 );
unsigned int id = getEdgeID( x, y, z, 7 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
}
if ( ( x == m_nX - 1 ) && ( y == m_nY - 1 ) )
if ( edgeTable[ tableIndex ] & 1024 )
{
POINT3DID pt = calculateIntersection( x, y, z, 10 );
unsigned int id = getEdgeID( x, y, z, 10 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( ( x == m_nX - 1 ) && ( z == m_nZ - 1 ) )
if ( edgeTable[ tableIndex ] & 64 )
{
POINT3DID pt = calculateIntersection( x, y, z, 6 );
unsigned int id = getEdgeID( x, y, z, 6 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
if ( ( y == m_nY - 1 ) && ( z == m_nZ - 1 ) )
if ( edgeTable[ tableIndex ] & 32 )
{
POINT3DID pt = calculateIntersection( x, y, z, 5 );
unsigned int id = getEdgeID( x, y, z, 5 );
QMutexLocker locker( m_mutex );
m_i2pt3idVertices->insert( id, pt );
locker.unlock();
}
for ( int i = 0; triTable[ tableIndex ][ i ] != -1; i += 3 )
{
TRIANGLE triangle;
unsigned int pointID0, pointID1, pointID2;
pointID0 = getEdgeID( x, y, z, triTable[ tableIndex ][ i ] );
pointID1 = getEdgeID( x, y, z, triTable[ tableIndex ][ i + 1 ] );
pointID2 = getEdgeID( x, y, z, triTable[ tableIndex ][ i + 2 ] );
triangle.pointID[ 0 ] = pointID0;
triangle.pointID[ 1 ] = pointID1;
triangle.pointID[ 2 ] = pointID2;
QMutexLocker locker( m_mutex );
m_trivecTriangles->push_back( triangle );
locker.unlock();
}
}
}
}
bool RS_ActionPolylineEquidistant::makeContour() {
if (container==NULL) {
RS_DEBUG->print("RS_ActionPolylineEquidistant::makeContour: no valid container",
RS_Debug::D_WARNING);
return false;
}
RS_Polyline* originalPolyline = (RS_Polyline*)originalEntity;
//create a list of entities to offset without length = 0
QList<RS_Entity*> entities;
for (RS_Entity* en=originalPolyline->firstEntity(); en!=NULL; en=originalPolyline->nextEntity()) {
if (en->getLength() > 1.0e-12)
entities.append(en);
}
if (entities.isEmpty()) {
return false;
}
if (document!=NULL) {
document->startUndoCycle();
}
double neg = 1.0;
if(bRightSide)
neg = -1.0;
// Create new helper entities
RS_Line line1(NULL, RS_LineData(RS_Vector(true), RS_Vector(true)));//current line
RS_Line lineFirst(NULL, RS_LineData(RS_Vector(true), RS_Vector(true)));//previous line
RS_Arc arc1(NULL, RS_ArcData(RS_Vector(true), 0,0,0,false));//current arc
RS_Arc arcFirst(NULL, RS_ArcData(RS_Vector(true), 0,0,0,false));//previous arc
for (int num=1; num<=number || (number==0 && num<=1); num++) {
RS_Polyline* newPolyline = new RS_Polyline(container);
newPolyline->setLayer(((RS_Polyline*)originalEntity)->getLayer());
newPolyline->setPen(((RS_Polyline*)originalEntity)->getPen());
bool first = true;
bool closed = originalPolyline->isClosed();
double bulge = 0.0;
RS_Entity* en;
RS_Entity* prevEntity = entities.last();
RS_Entity* currEntity;
for (int i = 0; i < entities.size(); ++i) {
en = entities.at(i);
RS_Vector v(false);
if (en->rtti()==RS2::EntityArc) {
currEntity = &arc1;
calculateOffset(currEntity, en, dist*num*neg);
bulge = arc1.getBulge();
} else {
currEntity = &line1;
bulge = 0.0;
calculateOffset(currEntity, en, dist*num*neg);
}
if (first) {
if (closed) {
if (prevEntity->rtti()==RS2::EntityArc) {
prevEntity = calculateOffset(&arcFirst, prevEntity, dist*num*neg);
} else {
prevEntity = calculateOffset(&lineFirst, prevEntity, dist*num*neg);
}
v = calculateIntersection(prevEntity, currEntity);
}
if (!v.valid) {
v = currEntity->getStartpoint();
closed = false;
} else if (currEntity->rtti()==RS2::EntityArc) {
//update bulge
arc1.setAngle1(arc1.getCenter().angleTo(v));
arc1.calculateEndpoints();
bulge = arc1.getBulge();
}
first = false;
if (!prevEntity) break; //prevent crash if not exist offset for prevEntity
} else {
v = calculateIntersection(prevEntity, currEntity);
if (!v.valid) {
v= prevEntity->getEndpoint();
double dess = currEntity->getStartpoint().distanceTo(prevEntity->getEndpoint());
if (dess > 1.0e-12) {
newPolyline->addVertex(v, bulge);
prevEntity = NULL;
break;
}
}
double startAngle = prevEntity->getStartpoint().angleTo(prevEntity->getEndpoint());
if (prevEntity->rtti()==RS2::EntityArc) {
arcFirst.setAngle2(arcFirst.getCenter().angleTo(v));
arcFirst.calculateEndpoints();
newPolyline->setNextBulge(arcFirst.getBulge());
}
//check if the entity are reverted
if (abs (prevEntity->getStartpoint().angleTo(prevEntity->getEndpoint())- startAngle) > 0.785) {
prevEntity = newPolyline->lastEntity();
RS_Vector v0 = calculateIntersection(prevEntity, currEntity);
if (prevEntity->rtti()==RS2::EntityArc) {
((RS_Arc*)prevEntity)->setAngle2(arcFirst.getCenter().angleTo(v0));
((RS_Arc*)prevEntity)->calculateEndpoints();
newPolyline->setNextBulge( ((RS_Arc*)prevEntity)->getBulge() );
} else {
((RS_Line*)prevEntity)->setEndpoint(v0);
newPolyline->setNextBulge( 0.0 );
}
newPolyline->setEndpoint(v0);
}
if (currEntity->rtti()==RS2::EntityArc) {
arc1.setAngle1(arc1.getCenter().angleTo(v));
arc1.calculateEndpoints();
bulge = arc1.getBulge();
} else
bulge = 0.0;
}
if (prevEntity) {
newPolyline->addVertex(v, bulge, false);
if (currEntity->rtti()==RS2::EntityArc) {
arcFirst.setData(arc1.getData());
arcFirst.calculateEndpoints();
prevEntity = &arcFirst;
} else {
lineFirst.setStartpoint(line1.getStartpoint());
lineFirst.setEndpoint(line1.getEndpoint());
prevEntity = &lineFirst;
}
}
}
//properly terminated, check closed
if (prevEntity) {
if (closed) {
if (currEntity->rtti()==RS2::EntityArc) {
arc1.setAngle2(arc1.getCenter().angleTo(newPolyline->getStartpoint()));
arc1.calculateEndpoints();
newPolyline->setNextBulge(arc1.getBulge());
bulge = arc1.getBulge();
}
newPolyline->setClosed(true, bulge);
} else {
newPolyline->addVertex(currEntity->getEndpoint(), bulge);
}
}
if (!newPolyline->isEmpty()) {
container->addEntity(newPolyline);
document->addUndoable(newPolyline);
}
}
if (document!=NULL) {
document->endUndoCycle();
}
if (graphicView!=NULL) {
graphicView->redraw();
}
return true;
}
