void CloudAtlasControlWindow::initWindow(osgWidget::WindowManager* wm, TemperatureProbeLayer* tLayer, WindowThemeSettings wts) { setZRange(1.0f); _obWM = wm; getBackground()->setColor(osgWidget::Color(0, 0, 0, 0)); getBackground()->setEventMask(osgWidget::EVENT_NONE); _wts = wts; osgWidget::Table* centerTable = new osgWidget::Table("CenterTable", 2, 1); centerTable->getBackground()->setColor(osgWidget::Color(0, 0, 0, 0)); _centerWidget = new CenterWidget("CloudAtlasCenterWidget", _windowWidth); float centerHeight = _centerWidget->buildCenterWidget(tLayer); osgWidget::point_type cw = wts._left; osgWidget::point_type ch = wts._bottom; osgWidget::point_type w = _windowWidth - cw - wts._right; osgWidget::point_type h = centerHeight + wts._topTitleHeight; osgWidget::Window::EmbeddedWindow* centerEW = new osgWidget::Window::EmbeddedWindow("CenterTableEmbedded", _windowWidth, h); centerEW->setCanFill(true); centerEW->setLayer(osgWidget::Widget::LAYER_MIDDLE); centerEW->setEventMask(osgWidget::EVENT_ALL); centerEW->setColor(1, 1, 1, 1); centerEW->setImage(wts._bgImage, true); addWidget(centerEW, 1, 1); osgWidget::Window::EmbeddedWindow* centerWidget = _centerWidget->embed("CenterEmbeddedWindow"); centerWidget->setEventMask(osgWidget::EVENT_ALL); centerWidget->setColor(0, 0, 0, 0); centerTable->addWidget(centerWidget, 0, 0); _topTitleWidget = new VirtualDataSceneWidget::TopTitleWidget("TopTitle", _windowWidth, wts._topTitleHeight, wts._topTitleImage, wts._topCloseButtonImage); osgWidget::Window::EmbeddedWindow* topBorderWidget = _topTitleWidget->embed("TopTitleEmbedded"); topBorderWidget->setColor(0, 0, 0, 0); topBorderWidget->setEventMask(osgWidget::EVENT_ALL); centerTable->addWidget(topBorderWidget, 1, 0); centerTable->resize(_windowWidth, h); setWindow(centerTable); //init left bottom right border and corner addWidget(new osgWidget::Frame::Corner(osgWidget::Frame::CORNER_LOWER_LEFT, cw, ch), 0, 0); addWidget(new osgWidget::Frame::Border(osgWidget::Frame::BORDER_BOTTOM, w, ch), 0, 1); addWidget(new osgWidget::Frame::Corner(osgWidget::Frame::CORNER_LOWER_RIGHT, cw, ch), 0, 2); addWidget(new osgWidget::Frame::Border(osgWidget::Frame::BORDER_LEFT, cw, h), 1, 0); addWidget(new osgWidget::Frame::Border(osgWidget::Frame::BORDER_RIGHT, cw, wts._right), 1, 2); addWidget(new osgWidget::Frame::Corner(osgWidget::Frame::CORNER_UPPER_LEFT, cw, wts._top), 2, 0); addWidget(new osgWidget::Frame::Border(osgWidget::Frame::BORDER_TOP, w, wts._top), 2, 1); addWidget(new osgWidget::Frame::Corner(osgWidget::Frame::CORNER_UPPER_RIGHT, cw, wts._top), 2, 2); getCorner(CORNER_UPPER_LEFT)->setImage(wts._leftTopImage, true); getBorder(BORDER_TOP)->setImage(wts._topImage, true); getCorner(CORNER_UPPER_RIGHT)->setImage(wts._rightTopImage, true); getBorder(BORDER_LEFT)->setImage(wts._leftImage, true); getBorder(BORDER_RIGHT)->setImage(wts._rightImage, true); getCorner(CORNER_LOWER_LEFT)->setImage(wts._leftBottomImage, true); getBorder(BORDER_BOTTOM)->setImage(wts._bottomImage, true); getCorner(CORNER_LOWER_RIGHT)->setImage(wts._rightBottomImage, true); _topTitleWidget->setCloseButtonClickCallback(&CloudAtlasControlWindow::closeButtonClicked, this); _topTitleWidget->setDragCallback(&CloudAtlasControlWindow::dragEventCallback, this); osgWidget::point_type allHeight = h + ch + wts._top; resize(_windowWidth, allHeight); }
void Cloth::printCorners() { int p0 = getCorner(0); int p1 = getCorner(1); int p2 = getCorner(2); int p3 = getCorner(3); std::cout<<"Corner 0 (R):"<<p0<<",at:"<<getPoint(p0)<<std::endl; std::cout<<"Corner 1 (G):"<<p1<<",at:"<<getPoint(p1)<<std::endl; std::cout<<"Corner 2 (B):"<<p2<<",at:"<<getPoint(p2)<<std::endl; std::cout<<"Corner 3 (W):"<<p3<<",at:"<<getPoint(p3)<<std::endl; }
/* * getMidPoint * * parameter p0 - int * parameter p1 - int * return - float * */ float * BoundingBox::getMidPoint(int p0, int p1) { float * point0; float * point1; float * point; point0 = getCorner(p0); point1 = getCorner(p1); point = midPoint(point0, point1); delete[] point0; delete[] point1; return point; } // end getMidPoint()
//***************************for setup*****************************// void Cloth::drawCorners(Graphic *g) { //RBGW g->setColor(Vector3(1,0,0)); g->transform(&Graphic::drawUnitSphere,getPoint(getCorner(0)),0, Vector3(.1,.1,.1)); g->setColor(Vector3(0,1,0)); g->transform(&Graphic::drawUnitSphere,getPoint(getCorner(1)),0, Vector3(.1,.1,.1)); g->setColor(Vector3(0,0,1)); g->transform(&Graphic::drawUnitSphere,getPoint(getCorner(2)),0, Vector3(.1,.1,.1)); g->setColor(Vector3(1,1,1)); g->transform(&Graphic::drawUnitSphere,getPoint(getCorner(3)),0, Vector3(.1,.1,.1)); }
void RS_Solid::draw(RS_Painter* painter, RS_GraphicView* view, double& /*patternOffset*/) { if (painter==NULL || view==NULL) { return; } RS_SolidData d = getData(); if (isTriangle()) { painter->fillTriangle(view->toGui(getCorner(0)), view->toGui(getCorner(1)), view->toGui(getCorner(2))); } }
// testface: given cube at lattice (i, j, k), and four corners of face, // if surface crosses face, compute other four corners of adjacent cube // and add new cube to cube stack void IsoSurfacePolygonizer::testFace(int i, int j, int k, const StackedCube &oldCube, CubeFace face, CubeCorner c1, CubeCorner c2, CubeCorner c3, CubeCorner c4) { static int facebit[6] = {2, 2, 1, 1, 0, 0}; int bit = facebit[face]; bool c1Positive = oldCube.m_corners[c1]->m_positive; // test if no surface crossing, cube out of bounds, or already visited: if(oldCube.m_corners[c2]->m_positive == c1Positive && oldCube.m_corners[c3]->m_positive == c1Positive && oldCube.m_corners[c4]->m_positive == c1Positive) { return; } // create new cube: StackedCube newCube(i, j, k,0); if(!addToDoneSet(newCube.m_key)) { return; } newCube.m_corners[FLIP(c1, bit)] = oldCube.m_corners[c1]; newCube.m_corners[FLIP(c2, bit)] = oldCube.m_corners[c2]; newCube.m_corners[FLIP(c3, bit)] = oldCube.m_corners[c3]; newCube.m_corners[FLIP(c4, bit)] = oldCube.m_corners[c4]; for(int n = 0; n < ARRAYSIZE(newCube.m_corners); n++) { if(newCube.m_corners[n] == NULL) { newCube.m_corners[n] = getCorner(i+BIT(n,2), j+BIT(n,1), k+BIT(n,0)); } } if( !m_boundingBox.contains(*newCube.m_corners[LBN]) || !m_boundingBox.contains(*newCube.m_corners[RTF])) { return; } pushCube(newCube); }
bool Box::culledBy( const class Plane* plane, int numPlanes, int& cullingPlane, const uint32 _inMask, uint32& childMask) const { uint32 inMask = _inMask; assert(numPlanes < 31); childMask = 0; // See if there is one plane for which all of the // vertices are in the negative half space. for (int p = 0; p < numPlanes; p++) { // Only test planes that are not masked if ((inMask & 1) != 0) { Vector3 corner; int numContained = 0; int v = 0; // We can early-out only if we have found one point on each // side of the plane (i.e. if we are straddling). That // occurs when (numContained < v) && (numContained > 0) for (v = 0; (v < 8) && ((numContained == v) || (numContained == 0)); ++v) { if (plane[p].halfSpaceContains(getCorner(v))) { ++numContained; } } if (numContained == 0) { // Plane p culled the box cullingPlane = p; // The caller should not recurse into the children, // since the parent is culled. If they do recurse, // make them only test against this one plane, which // will immediately cull the volume. childMask = 1 << p; return true; } else if (numContained < v) { // The bounding volume straddled the plane; we have // to keep testing against this plane childMask |= (1 << p); } } // Move on to the next bit. inMask = inMask >> 1; } // None of the planes could cull this box cullingPlane = -1; return false; }
Box AABB::toBox() { Box ret; for(int i =0;i<CORNERCOUNT;++i) { ret.vertices[i]= getCorner(static_cast<Corner>(i)); } return ret; }
CornerArray getCorners(const CornerTypeArray &order = Voxel::DEFAULT_ORDER) const { assert(order.size() == Corner::N_CORNERS); CornerArray tmp; u_int i = 0; CornerTypeArray::const_iterator tit; for (tit = order.begin(); tit != order.end(); ++tit) { tmp[i++] = getCorner(*tit); } return tmp; }
bool IsoSurfacePolygonizer::putInitialCube() { StackedCube cube(0,0,0, 0); m_cornerMap.clear(); // set corners of initial cube: for(int i = 0; i < ARRAYSIZE(cube.m_corners); i++) { cube.m_corners[i] = getCorner(BIT(i,2), BIT(i,1), BIT(i,0)); } if(cube.intersectSurface()) { addToDoneSet(cube.m_key); pushCube(cube); return true; } return false; }
bool ZIntCuboid::hasOverlap(const ZIntCuboid &box) const { bool overlapped = false; for (int i = 0; i < 8; ++i) { if (contains(box.getCorner(i))) { overlapped = true; break; } if (box.contains(getCorner(i))) { overlapped = true; break; } } return overlapped; }
ZIntPoint ZIntCuboidFace::getCornerCoordinates(int index) const { ZIntPoint pt; Corner corner = getCorner(index); switch (getAxis()) { case NeuTube::X_AXIS: pt.set(getPlanePosition(), corner.getX(), corner.getY()); break; case NeuTube::Y_AXIS: pt.set(corner.getX(), getPlanePosition(), corner.getY()); break; case NeuTube::Z_AXIS: pt.set(corner.getX(), corner.getY(), getPlanePosition()); break; } return pt; }
bool Box::culledBy( const class Plane* plane, int numPlanes, int& cullingPlane, const uint32 _inMask) const { uint32 inMask = _inMask; assert(numPlanes < 31); // See if there is one plane for which all of the // vertices are in the negative half space. for (int p = 0; p < numPlanes; p++) { // Only test planes that are not masked if ((inMask & 1) != 0) { bool culled = true; int v; // Assume this plane culls all points. See if there is a point // not culled by the plane... early out when at least one point // is in the positive half space. for (v = 0; (v < 8) && culled; ++v) { culled = ! plane[p].halfSpaceContains(getCorner(v)); } if (culled) { // Plane p culled the box cullingPlane = p; return true; } } // Move on to the next bit. inMask = inMask >> 1; } // None of the planes could cull this box cullingPlane = -1; return false; }
void CAxisAlgnBB::render(int argb) { SVertex verts[kNumCorners]; WORD indexList[kMaxIndices] = { 0, 2, 3, 3, 1, 0, 7, 6, 4, 4, 5, 7, 4, 6, 2, 2, 0, 4, 1, 3, 7, 7, 5, 1, 4, 0, 1, 1, 5, 4, 2, 6, 7, 7, 3, 2 }; // Fill in the 8 vertices for(int i = 0; i < kNumCorners; ++i) { CPos pos = getCorner(i); verts[i].x = pos.x; verts[i].y = pos.y; verts[i].z = pos.z; verts[i].color = argb; } // Render the AABB g3D->render(verts, kNumCorners, indexList, kMaxIndices); // Render lines on the top and bottom of the the front and // back sides of the box. This allow us to see the full dimensions // of the AABB better. for(int i = 0; i < kNumCorners; ++i) verts[i].color = D3DCOLOR_ARGB(255, 255, 255, 255); g3D->renderLine(verts, kNumCorners); }
template <typename T> vector3d<T> aabbox3d<T>::getClosestPoint(const plane3d<T> &Plane) const { vector3d<T> Result, Corner; T Distance = math::OMEGA; T Temp; for (s32 i = 0; i < 8; ++i) { Corner = getCorner(i); Temp = Plane.getPointDistance(Corner); if (Temp < Distance) { Result = Corner; Distance = Temp; } } return Result; }
//Check for cross with Diagonal line-segment defined from the top-L to bottom-R corner of square. //If it crosses, perform actions with Cross() bool MakeStackIcon::checkForCross(Vec3 currPoint, Vec3 prevPoint) { Vec3 target[4]; if (enabled) { // Create a bounding box where the StackIcon resides for (uint i = 0; i < 4; i++) { target[i] = WorldToClient(getCorner(i + 1)); target[i].z = 0.0f; // Corner Index: // 1 2 // +--------+ // | | // | ICON | // | | // +--------+ // 3 0 } // Crossing target is defined as -size/2 to size/2 on the z-axis, centered at 'position' if (currPoint.x >= target[3].x && currPoint.x <= target[0].x && currPoint.y <= target[3].y && currPoint.y >= target[1].y) { // ensure that we're not hitting a straight line if (lassoMenu->getCurvatureRatio() > 1.2f) { return lassoMenu->isTailVectorPointingToStackIcon(20.0f); } } } return false; }
Eigen::Vector3d getCorner(Corner::CornerType c) const { return getCorner(static_cast<u_char>(c)); }
template<> RotBox<3>& RotBox<3>::rotateCorner(const Quaternion& q, int corner) { rotatePoint(q, getCorner(corner)); return *this; }
void Cloth::pinCorners() { this->createPin(getCorner(0)); this->createPin(getCorner(1)); this->createPin(getCorner(2)); this->createPin(getCorner(3)); }
Line3d Triangle3d::getEdgeLine ( int whichEdge ) const { return Line3d(getCorner(whichEdge),getEdgeDir(whichEdge)); }
Segment3d Triangle3d::getEdgeSegment ( int whichSegment ) const { return Segment3d(getCorner(whichSegment),getCorner(whichSegment+1)); }
Vector Triangle3d::getEdgeDir ( int whichEdge ) const { return getCorner(whichEdge+1) - getCorner(whichEdge); }
//! \brief Constrain a given vertex to a given node. //! \param item item Vertex index on patch. //! \param comp Component to constrain //! \param basis Basis to constrain vertex for. //! \param idx Global node to constrain edge to. void constrainVertex(int item, int comp, int basis, int idx) { int gn = bpch->getNodeID(getCorner(item, basis)); if (gn != idx) bpch->add2PC(gn, comp, idx); }
void AABB::render() const { // Minimum to avoid trouble when building on pure OpenGL ES systems // Not sure about ANGLE! #if !defined(QT_OPENGL_ES_2) Vec3f nbl = getCorner(MinMinMin); Vec3f nbr = getCorner(MaxMinMin); Vec3f ntr = getCorner(MaxMinMax); Vec3f ntl = getCorner(MinMinMax); Vec3f fbl = getCorner(MinMaxMin); Vec3f fbr = getCorner(MaxMaxMin); Vec3f ftr = getCorner(MaxMaxMax); Vec3f ftl = getCorner(MinMaxMax); glExtFuncs->glColor3f(1.0f, 1.0f, 1.0f); float oldLineWidth; glExtFuncs->glGetFloatv(GL_LINE_WIDTH, &oldLineWidth); glExtFuncs->glLineWidth(5); glExtFuncs->glBegin(GL_LINE_LOOP); //near plane glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]); glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]); glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]); glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]); glExtFuncs->glEnd(); glExtFuncs->glBegin(GL_LINE_LOOP); //far plane glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]); glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]); glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]); glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]); glExtFuncs->glEnd(); glExtFuncs->glBegin(GL_LINE_LOOP); //bottom plane glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]); glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]); glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]); glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]); glExtFuncs->glEnd(); glExtFuncs->glBegin(GL_LINE_LOOP); //top plane glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]); glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]); glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]); glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]); glExtFuncs->glEnd(); glExtFuncs->glBegin(GL_LINE_LOOP); //left plane glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]); glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]); glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]); glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]); glExtFuncs->glEnd(); glExtFuncs->glBegin(GL_LINE_LOOP); // right plane glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]); glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]); glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]); glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]); glExtFuncs->glEnd(); glExtFuncs->glLineWidth(oldLineWidth); #endif }