void TestDim::index() { Dim sca; Dim row2(Dim::row_vec(2)); Dim row3(Dim::row_vec(3)); Dim col2(Dim::col_vec(2)); Dim col3(Dim::col_vec(3)); Dim mat22(Dim::matrix(2,2)); Dim mat32(Dim::matrix(3,2)); Dim mat23(Dim::matrix(2,3)); Dim mat33(Dim::matrix(3,3)); CPPUNIT_ASSERT (sca.index_dim(DoubleIndex::one_elt(sca,0,0))==sca); CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::one_elt(row3,0,0))==sca); CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::one_row(row3,0))==row3); CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::cols(row3,0,1))==row2); CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::one_elt(col3,0,0))==sca); CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::one_col(col3,0))==col3); CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::rows(col3,0,1))==col2); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_elt(mat23,0,0))==sca); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_row(mat23,0))==row3); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_col(mat23,0))==col2); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::cols(mat23,0,1))==mat22); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::subrow(mat23,0,0,1))==row2); CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::all(mat23))==mat23); CPPUNIT_ASSERT (mat32.index_dim(DoubleIndex::subcol(mat32,0,1,0))==col2); CPPUNIT_ASSERT (mat33.index_dim(DoubleIndex::rows(mat33,0,1))==mat23); CPPUNIT_ASSERT (mat33.index_dim(DoubleIndex::cols(mat33,0,1))==mat32); }
void FibreReader<DIM>::GetAllOrtho(std::vector< c_vector<double, DIM> >& first_direction, std::vector< c_vector<double, DIM> >& second_direction, std::vector< c_vector<double, DIM> >& third_direction) { assert(first_direction.empty()); assert(second_direction.empty()); assert(third_direction.empty()); if (mNumItemsPerLine != DIM*DIM) { EXCEPTION("Use GetAllAxi when reading axisymmetric fibres"); } for (unsigned i=0; i<mNumLinesOfData; i++) { c_matrix<double, DIM, DIM> temp_matrix; GetFibreSheetAndNormalMatrix(i, temp_matrix, true); //Note that although the matrix appears row-wise in the ascii .ortho file, //for convenience it is stored column-wise. matrix_column<c_matrix<double, DIM, DIM> > col0(temp_matrix, 0); first_direction.push_back(col0); if (DIM>=2) { matrix_column<c_matrix<double, DIM, DIM> > col1(temp_matrix, 1); second_direction.push_back(col1); } if (DIM==3) { matrix_column<c_matrix<double, DIM, DIM> > col2(temp_matrix, 2); third_direction.push_back(col2); } } }
TEST(PaletteTranslator, BuildSortLuminance) { //uint32 y = r * 299 + g * 587 + b * 114; Color col0(0, 0, 10); Color col1(0, 0, 11); Color col2(10, 0, 0); Color col3(11, 0, 0); Color col4(0, 10, 0); Color col5(0, 11, 0); Palette pal; pal.m_count = 6; pal[0] = col3; pal[1] = col5; pal[2] = col1; pal[3] = col2; pal[4] = col4; pal[5] = col0; Palette exp; exp.m_count = 6; exp[0] = col0; exp[1] = col1; exp[2] = col2; exp[3] = col3; exp[4] = col4; exp[5] = col5; PaletteTranslator pt; pt.BuildSortLuminance(pal, nullptr); ASSERT_TRUE( pal == exp ); }
Matrix4 Matrix4::multiply(Matrix4 a) { Matrix4 b; /* for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { b.m[i][j] = m[0][j] * a.m[i][0] + m[1][j] * a.m[i][1] + m[2][j] * a.m[i][2] + m[3][j] * a.m[i][3]; } }*/ Vector4 row1(m[0][0], m[1][0], m[2][0], m[3][0]); Vector4 row2(m[0][1], m[1][1], m[2][1], m[3][1]); Vector4 row3(m[0][2], m[1][2], m[2][2], m[3][2]); Vector4 row4(m[0][3], m[1][3], m[2][3], m[3][3]); Vector4 col1(a.m[0][0], a.m[0][1], a.m[0][2], a.m[0][3]); Vector4 col2(a.m[1][0], a.m[1][1], a.m[1][2], a.m[1][3]); Vector4 col3(a.m[2][0], a.m[2][1], a.m[2][2], a.m[2][3]); Vector4 col4(a.m[3][0], a.m[3][1], a.m[3][2], a.m[3][3]); b.set(row1.dot(col1), row2.dot(col1), row3.dot(col1), row4.dot(col1), row1.dot(col2), row2.dot(col2), row3.dot(col2), row4.dot(col2), row1.dot(col3), row2.dot(col3), row3.dot(col3), row4.dot(col3), row1.dot(col4), row2.dot(col4), row3.dot(col4), row4.dot(col4)); return b; }
BOOST_AUTO_TEST_CASE_TEMPLATE(create, T, float_types) { // default constructor vmath::core::Matrix<T, 3, 2> M_default; BOOST_CHECK_SMALL(M_default[0][0], static_cast<T>(1e-7)); BOOST_CHECK_SMALL(M_default[0][1], static_cast<T>(1e-7)); BOOST_CHECK_SMALL(M_default[0][2], static_cast<T>(1e-7)); BOOST_CHECK_SMALL(M_default[1][0], static_cast<T>(1e-7)); BOOST_CHECK_SMALL(M_default[1][1], static_cast<T>(1e-7)); BOOST_CHECK_SMALL(M_default[1][2], static_cast<T>(1e-7)); // parameterized constructor std::array<vmath::core::Vector<T, 3>, 2> data = {{ vmath::core::Vector<T, 3>(static_cast<T>(1.0), static_cast<T>(2.0), static_cast<T>(3.0)), vmath::core::Vector<T, 3>(static_cast<T>(4.0), static_cast<T>(5.0), static_cast<T>(6.0)) }}; vmath::core::Matrix<T, 3, 2> M_param(data); BOOST_CHECK_CLOSE(M_param[0][0], static_cast<T>(1.0), 1e-4f); BOOST_CHECK_CLOSE(M_param[0][1], static_cast<T>(2.0), 1e-4f); BOOST_CHECK_CLOSE(M_param[0][2], static_cast<T>(3.0), 1e-4f); BOOST_CHECK_CLOSE(M_param[1][0], static_cast<T>(4.0), 1e-4f); BOOST_CHECK_CLOSE(M_param[1][1], static_cast<T>(5.0), 1e-4f); BOOST_CHECK_CLOSE(M_param[1][2], static_cast<T>(6.0), 1e-4f); // parameterized constructor vmath::core::Vector<T, 3> col1(static_cast<T>(1.0), static_cast<T>(2.0), static_cast<T>(3.0)); vmath::core::Vector<T, 3> col2(static_cast<T>(4.0), static_cast<T>(5.0), static_cast<T>(6.0)); vmath::core::Matrix<T, 3, 2> M_param2(col1, col2); BOOST_CHECK_CLOSE(M_param2[0][0], static_cast<T>(1.0), 1e-4f); BOOST_CHECK_CLOSE(M_param2[0][1], static_cast<T>(2.0), 1e-4f); BOOST_CHECK_CLOSE(M_param2[0][2], static_cast<T>(3.0), 1e-4f); BOOST_CHECK_CLOSE(M_param2[1][0], static_cast<T>(4.0), 1e-4f); BOOST_CHECK_CLOSE(M_param2[1][1], static_cast<T>(5.0), 1e-4f); BOOST_CHECK_CLOSE(M_param2[1][2], static_cast<T>(6.0), 1e-4f); }
void ScreenAlignedText::tessellate(void) { //cout << "ScreenAlignedText::tessellate called" << endl; if( _mfText.empty() ) return; Text fontText; //SFSharedFontStylePtr *psfsp = getSFFont(); //SFSharedFontStyleWrapperPtr *wrapperPtr = getSFFont(); SharedFontStyleWrapperPtr wrapperPtr = getFont(); //SFSharedFontStylePtr psfsp = wrapperPtr->getSFFStyleContainer(); //SharedFontStylePtr psfs = psfsp->getValue(); SharedFontStylePtr psfs = wrapperPtr->getFStyleContainer(); if( psfs == NullFC ) { cerr << "ScreenAlignedText::tessellate: psfs = NullFC ! " << endl; return; } FontStyleP pFS = psfs->getContainedFontStyle(); if( pFS == NULL ) { cerr << "ScreenAlignedText::tessellate: pFS = NULL ! " << endl; return; } fontText.setFontStyle( pFS ); fontText.setJustifyMajor(MIDDLE_JT); // Colors are changed during rendering, // but are needed for // calling the fillImage routine Color4ub col1( 255, 255, 255, 255); Color4ub col2( 0, 0, 0, 0 ); ImagePtr pImg = Image::create(); std::vector<std::string> lineVec; for(unsigned int i = 0; i < _mfText.size(); i++ ) { lineVec.push_back( _mfText[i] ); } vector<NodePtr> cNodes; if(fontText.fillImage(pImg, lineVec, &col1, &col2, false, 0, 0, SET_TEX_TCM, CLEAR_ADD_MM, 1, true ) ) { _sfRenderImage.setValue( pImg ); } // cout << "ScreenAlignedText::tessellate(void)" << endl; }
void WriteBMP::rayIncr(vec3* colorVec, vec3* rayPos, vec3 rayToIncr, float* T, float k, float rayLength) { *Q = 1.0f; *Q2 = 1.0f; int ind = WriteBMP::getVoxelIndex(rayPos); if (ind == -1) { if (*entered || length(*eye - *rayPos) > rayLength) { *colorVec += *T * *bgColor; return; } *dens = 0.0f; } else { *entered = true; Voxel vox = allVoxels[ind]; *dens = *vox.density; vec3 lidir; vec3* ldir; if (*vox.lightVal == -1 && *dens != 0.0f) { lrPos->x = lightPos->x; lrPos->y = lightPos->y; lrPos->z = lightPos->z; lidir = normalize(*rayPos - *lightPos); ldir = new vec3(lidir.x, lidir.y, lidir.z); *ldir *= *stepSize; lightMarch(lightPos, lrPos, ldir, Q, length(*lightPos - *rayPos), 0.5f); *vox.lightVal = *Q; } else { *Q = *vox.lightVal; } if (*vox.lightVal2 == -1 && *dens != 0.0f) { lidir = normalize(*rayPos - *lightPos2); ldir = new vec3(lidir.x, lidir.y, lidir.z); *ldir *= *stepSize; lrPos->x = lightPos2->x; lrPos->y = lightPos2->y; lrPos->z = lightPos2->z; lightMarch(lightPos2, lrPos, ldir, Q2, length(*lightPos2 - *rayPos), 0.5f); *vox.lightVal2 = *Q2; } else { *Q2 = *vox.lightVal2; } } vec3 col(lightCol->x * matColor->x, lightCol->y * matColor->y, lightCol->z * matColor->z); vec3 col2(lightCol2->x * matColor->x, lightCol2->y * matColor->y, lightCol2->z * matColor->z); float dT = exp(-1.0f * k * *stepSize * *dens); *T *= dT; *rayPos += rayToIncr; *colorVec += ((1 - dT)/k) * *T * col * *Q; *colorVec += ((1 - dT)/k) * *T * col2 * *Q2; *colorVec = clamp(*colorVec, 0.0f, 1.0f); if (*T < 0.01) { *colorVec += *T * *bgColor; return; } rayIncr(colorVec, rayPos, rayToIncr, T, k, rayLength); }
/** * Decomposes matrix M such that T * R * S = M, where T is translation matrix, * R is rotation matrix and S is scaling matrix. * http://code.google.com/p/assimp-net/source/browse/trunk/AssimpNet/Matrix4x4.cs * (this method is exact to at least 0.0001f) * * | 1 0 0 T1 | | R11 R12 R13 0 | | a 0 0 0 | | aR11 bR12 cR13 T1 | * | 0 1 0 T2 |.| R21 R22 R23 0 |.| 0 b 0 0 | = | aR21 bR22 cR23 T2 | * | 0 0 0 T3 | | R31 R32 R33 0 | | 0 0 c 0 | | aR31 bR32 cR33 T3 | * | 0 0 0 1 | | 0 0 0 1 | | 0 0 0 1 | | 0 0 0 1 | * * @param m (in) matrix to decompose * @param scaling (out) scaling vector * @param rotation (out) rotation matrix * @param translation (out) translation vector */ void decomposeTRS(const glm::mat4& m, glm::vec3& translation, glm::mat4& rotation, glm::vec3& scaling) { // Extract the translation translation.x = m[3][0]; translation.y = m[3][1]; translation.z = m[3][2]; // Extract col vectors of the matrix glm::vec3 col1(m[0][0], m[0][1], m[0][2]); glm::vec3 col2(m[1][0], m[1][1], m[1][2]); glm::vec3 col3(m[2][0], m[2][1], m[2][2]); //Extract the scaling factors scaling.x = glm::length(col1); scaling.y = glm::length(col2); scaling.z = glm::length(col3); // Handle negative scaling if (glm::determinant(m) < 0) { scaling.x = -scaling.x; scaling.y = -scaling.y; scaling.z = -scaling.z; } // Remove scaling from the matrix if (scaling.x != 0) { col1 /= scaling.x; } if (scaling.y != 0) { col2 /= scaling.y; } if (scaling.z != 0) { col3 /= scaling.z; } rotation[0][0] = col1.x; rotation[0][1] = col1.y; rotation[0][2] = col1.z; rotation[0][3] = 0.0; rotation[1][0] = col2.x; rotation[1][1] = col2.y; rotation[1][2] = col2.z; rotation[1][3] = 0.0; rotation[2][0] = col3.x; rotation[2][1] = col3.y; rotation[2][2] = col3.z; rotation[2][3] = 0.0; rotation[3][0] = 0.0; rotation[3][1] = 0.0; rotation[3][2] = 0.0; rotation[3][3] = 1.0; }
int main() { zdb::Database database(L"test"); zdb::DbColumn col1(L"lalka1", DbDataType::Int32); zdb::DbColumn col2(L"lalka2", DbDataType::Int64); zdb::DbColumn col3(L"lalka3", DbDataType::Int8); std::vector<zdb::DbColumn> columns = { col1, col2, col3 }; database.AddTable(L"testTable", columns); return 0; }
/* GLTexture::bgTex * Returns the global chequered 'background' texture *******************************************************************/ GLTexture& GLTexture::bgTex() { if (!tex_background.isLoaded()) { wxColour col1(bgtx_colour1); wxColour col2(bgtx_colour2); tex_background.genChequeredTexture(8, rgba_t(col1.Red(), col1.Green(), col1.Blue(), 255), rgba_t(col2.Red(), col2.Green(), col2.Blue(), 255)); } return tex_background; }
void CGpApp::DrawEnergyBar() { LC_RECTF rc1(0,0, (FLOAT)INT(1.5F * ENERGYBARmax), 16); LC_RECTF rc2(0,0, (FLOAT)INT(1.5F * ENERGYBARmax * m_ShieldEnergy / SHIELDENERGYmax), 16); LCXVECTOR2 vcTrn(0, m_nScnH - 20.0F); LCXCOLOR col2(1,0,0,0.7F); LCXCOLOR col1(0,0,1,0.7F); m_pSpt->DrawEx(NULL, &rc1, &vcTrn, NULL, NULL, 0, &col1); m_pSpt->Draw(NULL, &rc2, &vcTrn, &col2); }
//------------------------------------------------------------------------------- // @ IvRenderer::SetWorldMatrix() //------------------------------------------------------------------------------- // Sets the world matrix for the renderer //------------------------------------------------------------------------------- void IvRenderer::SetWorldMatrix(const IvMatrix44& matrix) { mWorldMat = matrix; mWVPMat = mProjectionMat*mViewMat*mWorldMat; IvMatrix33 worldMat3x3; IvVector3 col0(mWorldMat(0,0), mWorldMat(1,0), mWorldMat(2,0)); IvVector3 col1(mWorldMat(0,1), mWorldMat(1,1), mWorldMat(2,1)); IvVector3 col2(mWorldMat(0,2), mWorldMat(1,2), mWorldMat(2,2)); worldMat3x3.SetColumns(col0, col1, col2); mNormalMat.Rotation(Transpose(Inverse(worldMat3x3))); }
LOCAL_C void CreateTable() { CDbColSet *cs=CDbColSet::NewLC(); TDbCol col1(KColumnInt,EDbColInt32); col1.iAttributes=TDbCol::ENotNull; cs->AddL(col1); TDbCol col2(KColumnText,EDbColText,200/sizeof(TText)); col2.iAttributes=TDbCol::ENotNull; cs->AddL(col2); test(TheDatabase.CreateTable(KTableName,*cs)==KErrNone); CleanupStack::PopAndDestroy(); }
void ColumnMajorMatrixTest::ThreeColConstructor() { VectorValue<Real> col1( 1, 2, 3 ); VectorValue<Real> col2( 4, 5, 6 ); VectorValue<Real> col3( 7, 8, 9 ); ColumnMajorMatrix test( col1, col2, col3 ); CPPUNIT_ASSERT( test == *a ); CPPUNIT_ASSERT( test.numEntries() == 9 ); }
// extract frustum plane in world space. // the normals facing inward. // pass in view * projection matrix. void Frustum::InitFromMatrix(const Matrix &VP) { // near and far plane corners static float3 verts[8] = { // near plane corners float3( -1, -1,0 ), float3( 1, -1,0 ), float3( 1, 1,0 ), float3( -1, 1 ,0), // far plane corners. float3( -1, -1 ,1), float3( 1, -1,1 ), float3( 1, 1,1 ), float3( -1, 1,1 ) }; this->m_matrix = VP; float4 col0(VP(0,0), VP(1,0), VP(2,0), VP(3,0)); float4 col1(VP(0,1), VP(1,1), VP(2,1), VP(3,1)); float4 col2(VP(0,2), VP(1,2), VP(2,2), VP(3,2)); float4 col3(VP(0,3), VP(1,3), VP(2,3), VP(3,3)); // Planes face inward. m_planes[Near] = Plane(col2); // near m_planes[Far] = Plane(col3 - col2); // far m_planes[Left] = Plane(col3 + col0); // left m_planes[Right] = Plane(col3 - col0); // right m_planes[Top] = Plane(col3 - col1); // top m_planes[Bottom] = Plane(col3 + col1); // bottom // normalize all six planes for(int i = 0; i < 6; i++) { m_planes[i].Normalize(); } // tranform eight corner from device coordiate to world coordinate. Matrix invVP = VP; invVP.Invert(); for(int i = 0; i < 8; i++) { this->m_corners[i] = float3::Transform(verts[i],invVP); } }
void wxZEdit::EndPanel() { wxCaptionBarStyle style; wxColour col1(193,208,233), col2(49,106,197); style.SetFirstColour(col1); style.SetSecondColour(col2); style.SetCaptionStyle(wxCAPTIONBAR_FILLED_RECTANGLE); m_pnl->ApplyCaptionStyleAll(style); // ask for a resize wxSizeEvent mevent( GetSize()+wxSize(1,1), GetId() ); mevent.SetEventObject( this ); ProcessEvent( mevent ); }
void door(void) { initLeds(); col1(); col4(); col7(); _delay_ms(200); col1(); col5(); col9(); _delay_ms(200); col1(); col2(); col3(); _delay_ms(200); }
void PaletteGrid::mouseMoveEvent(QMouseEvent* event) { VoxelFile* voxel = window->get_voxel(); if (!voxel) return; if (!(event->buttons() & Qt::LeftButton)) return; if ((event->pos() - drag_start).manhattanLength() < QApplication::startDragDistance()) return; QDrag* drag = new QDrag(this); QMimeData* mimeData = new QMimeData; RGBColor& col = global_palette[palette_index]; QColor col2(col.r, col.g, col.b); mimeData->setColorData(col2); drag->setMimeData(mimeData); //Qt::DropAction dropAction = drag->exec(Qt::CopyAction); }
void IrrDriver::renderLightsScatter(unsigned pointlightcount) { getFBO(FBO_HALF1).Bind(); glClearColor(0., 0., 0., 0.); glClear(GL_COLOR_BUFFER_BIT); const Track * const track = World::getWorld()->getTrack(); // This function is only called once per frame - thus no need for setters. float start = track->getFogStart() + .001; const video::SColor tmpcol = track->getFogColor(); core::vector3df col(tmpcol.getRed() / 255.0f, tmpcol.getGreen() / 255.0f, tmpcol.getBlue() / 255.0f); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); FullScreenShader::FogShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture()); DrawFullScreenEffect<FullScreenShader::FogShader>(1.f / (40.f * start), col); glEnable(GL_DEPTH_TEST); core::vector3df col2(1., 1., 1.); glUseProgram(LightShader::PointLightScatterShader::getInstance()->Program); glBindVertexArray(LightShader::PointLightScatterShader::getInstance()->vao); LightShader::PointLightScatterShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture()); LightShader::PointLightScatterShader::getInstance()->setUniforms(1.f / (40.f * start), col2); glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, MIN2(pointlightcount, MAXLIGHT)); glDisable(GL_BLEND); m_post_processing->renderGaussian6Blur(getFBO(FBO_HALF1), getFBO(FBO_HALF2), 5., 5.); glEnable(GL_BLEND); glDisable(GL_DEPTH_TEST); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); getFBO(FBO_COLORS).Bind(); m_post_processing->renderPassThrough(getRenderTargetTexture(RTT_HALF1)); }
//============================================================================== void DebugDrawer::drawGrid() { Vec4 col0(0.5, 0.5, 0.5, 1.0); Vec4 col1(0.0, 0.0, 1.0, 1.0); Vec4 col2(1.0, 0.0, 0.0, 1.0); const F32 SPACE = 1.0; // space between lines const U NUM = 57; // lines number. must be odd const F32 GRID_HALF_SIZE = ((NUM - 1) * SPACE / 2); setColor(col0); begin(GL_LINES); for(U x = - NUM / 2 * SPACE; x < NUM / 2 * SPACE; x += SPACE) { setColor(col0); // if the middle line then change color if(x == 0) { setColor(col1); } // line in z pushBackVertex(Vec3(x, 0.0, -GRID_HALF_SIZE)); pushBackVertex(Vec3(x, 0.0, GRID_HALF_SIZE)); // if middle line change col so you can highlight the x-axis if(x == 0) { setColor(col2); } // line in the x pushBackVertex(Vec3(-GRID_HALF_SIZE, 0.0, x)); pushBackVertex(Vec3(GRID_HALF_SIZE, 0.0, x)); } // render end(); }
void Camera::buildFrustumPlanes() { D3DXMATRIX VP = m_view * m_proj; D3DXVECTOR4 col0(VP(0, 0), VP(1, 0), VP(2, 0), VP(3, 0)); D3DXVECTOR4 col1(VP(0, 1), VP(1, 1), VP(2, 1), VP(3, 1)); D3DXVECTOR4 col2(VP(0, 2), VP(1, 2), VP(2, 2), VP(3, 2)); D3DXVECTOR4 col3(VP(0, 3), VP(1, 3), VP(2, 3), VP(3, 3)); // Planes face inward. mFrustumPlanes[0] = (D3DXPLANE)(col2); // near mFrustumPlanes[1] = (D3DXPLANE)(col3 - col2); // far mFrustumPlanes[2] = (D3DXPLANE)(col3 + col0); // left mFrustumPlanes[3] = (D3DXPLANE)(col3 - col0); // right mFrustumPlanes[4] = (D3DXPLANE)(col3 - col1); // top mFrustumPlanes[5] = (D3DXPLANE)(col3 + col1); // bottom for (int i = 0; i < 6; i++) D3DXPlaneNormalize(&mFrustumPlanes[i], &mFrustumPlanes[i]); }
void SqlBackendTest::collections() { Collection col( "Article" ); Article *article; CollectionIterator it( col.begin() ); CollectionIterator end( col.end() ); for ( ; it != end; ++it ) { article = static_cast<Article*>( *it ); // As long as we don't have a way to sort collections, we won't be // able to make this test nicer if ( article->label() != "Article One" && article->label() != "Article Two" ) { CHECK( true, false ); } } ObjectRef<Customer> c1 = Customer::create(); c1->setCustomerName( "foo" ); ObjectRef<Customer> c2 = Customer::create(); c2->setCustomerName( "bar" ); ObjectRef<Article> a1 = Article::create(); a1->setLabel( "foo" ); a1->setDescription( "liluli foo liluli" ); ObjectRef<CustomerOrder> o1 = CustomerOrder::create(); o1->setNumber( 3000 ); o1->setCustomer( c1 ); o1->articles()->add( a1 ); Manager::self()->commit(); Collection col2( "SELECT Customer.* WHERE Customer.Customer_CustomerOrder.Article_CustomerOrder.description like '%foo%'" ); Customer *customer; CollectionIterator it2( col2.begin() ); CollectionIterator end2( col2.end() ); CHECK( col2.begin() == col2.end(), false ); for ( ; it2 != end2; ++it2 ) { customer = static_cast<Customer*>( *it2 ); // As long as we don't have a way to sort collections, we won't be // able to make this test nicer CHECK( customer->customerName(), QString( "foo" ) ); } }
bool CopyArrayOperator:: SplitDisconnectedUnit( DepCompCopyArrayCollect& collect, DepCompCopyArrayCollect::CopyArrayUnit& unit, DepCompAstRefGraphCreate& refDep, DepCompCopyArrayCollect::CopyArrayUnit::NodeSet& cuts) { assert(unit.refs.size() > 0); DepCompCopyArrayCollect::CopyArrayUnit::InsideGraph insidegraph(&refDep,unit); const DepCompAstRefGraphNode* cur = *unit.refs.begin(); GraphGetNodeReachable<DepCompCopyArrayCollect::CopyArrayUnit::InsideGraph, AppendPtrSet<const DepCompAstRefGraphNode> > op; DepCompCopyArrayCollect::CopyArrayUnit::NodeSet innodes; AppendPtrSet<const DepCompAstRefGraphNode> col1(innodes), col2(cuts); op(&insidegraph, cur, GraphAccess::EdgeIn,col1); for (DepCompCopyArrayCollect::CopyArrayUnit::NodeSet::const_iterator p1 = innodes.begin(); !p1.ReachEnd(); ++p1) { op(&insidegraph, (*p1), GraphAccess::EdgeOut,col2); } cuts |= innodes; return cuts.size() < unit.refs.size(); }
TextureManager::TextureManager() { sf::Image textureimage; textureimage.create(32, 32, sf::Color(255, 0, 0)); sf::Color col1(254, 254, 234); sf::Color col2(0, 72, 180); for(int i = 0; i < 32; ++i) { for(int j = i * 0.5; j < 32 - (i * 0.5); ++j) { textureimage.setPixel(i, j, col1); } } for(int i = 0; i < 32; ++i) { textureimage.setPixel(31, i, col2); textureimage.setPixel(i, 31, col2); } fallbacktexture = new sf::Texture(); fallbacktexture->loadFromImage(textureimage); }
TEST(PaletteTranslator, BuildDuplicatedColors) { Color col0(11, 12, 13); Color col1(14, 15, 16); Color col2(20, 21, 22, 0); Color col3(11, 12, 13); Color col4(30, 31, 32, 0); Palette pal; pal.m_count = 5; pal[0] = col0; pal[1] = col1; pal[2] = col2; pal[3] = col3; pal[4] = col4; Palette exp; exp.m_count = 3; exp[0] = col0; exp[1] = col1; exp[2] = col2; uint32 colCounts[256] = { 1, 10, 100, 1000, 10000 }; uint32 expectedColCounts[256] = { 1001, 10, 10100, 0, 0 }; PaletteTranslator pt; pt.BuildDuplicatedColors(pal, colCounts); ASSERT_TRUE( pal == exp ); ASSERT_TRUE( memcmp(colCounts, expectedColCounts, sizeof(colCounts)) == 0 ); uint8 pixels[] = { 0, 1, 2, 3, 4 }; const uint8 expectedPixels[] = { 0, 1, 2, 0, 2 }; pt.Translate(pixels, sizeof(pixels)); ASSERT_TRUE( memcmp(pixels, expectedPixels, sizeof(pixels)) == 0 ); }
void TestDim::vec() { Dim sca; Dim row2(Dim::row_vec(2)); Dim row3(Dim::row_vec(3)); Dim col2(Dim::col_vec(2)); Dim col3(Dim::col_vec(3)); Dim mat22(Dim::matrix(2,2)); Dim mat32(Dim::matrix(3,2)); Dim mat23(Dim::matrix(2,3)); Dim mat33(Dim::matrix(3,3)); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca),true)==sca); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca),false)==sca); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca),true)==row2); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca),false)==col2); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca,sca),true)==row3); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca,sca),false)==col3); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,col2),true),DimException); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,col2),false)==col3); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,row2),true)==row3); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,row2),false),DimException); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,mat22),true),DimException); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,mat22),false),DimException); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2),true)==col2); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2),false)==col2); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2),true)==mat22); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2),false)==Dim::col_vec(4)); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2,col2),true)==mat23); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2,col2),false)==Dim::col_vec(6)); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,row2),true),DimException); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,row2),false),DimException); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,mat22),true)==mat23); CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,mat22),false),DimException); CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,mat22,col2),true)==Dim::matrix(2,4)); }
int Lua_Color_Equal(LuaPlus::LuaState *lua) { LuaPlus::LuaStack args(lua); float a[2]={0}, r[2]={0}, g[2]={0}, b[2]={0}; if (args.Count()==2) { for (int i=0; i<2; i++) { if (args[i+1].IsTable()) { if (args[i+1]["a"].IsNumber()) a[i]=args[i+1]["a"].GetFloat(); if (args[i+1]["r"].IsNumber()) r[i]=args[i+1]["r"].GetFloat(); if (args[i+1]["g"].IsNumber()) g[i]=args[i+1]["g"].GetFloat(); if (args[i+1]["b"].IsNumber()) b[i]=args[i+1]["b"].GetFloat(); } } } RUGE::CColor col1(a[0], r[0], g[0], b[0]), col2(a[1], r[1], g[1], b[1]); lua->PushBoolean(col1==col2 ? true : false); return 1; }
void KNDdeTorusCollocation::init(const KNVector& sol, const KNVector& par) { double* t1 = new double[NTAU+1]; double* t2 = new double[NTAU+1]; for (size_t i2 = 0; i2 < nint2; i2++) { for (size_t i1 = 0; i1 < nint1; i1++) { for (size_t j2 = 0; j2 < ndeg2; j2++) { for (size_t j1 = 0; j1 < ndeg1; j1++) { const size_t idx = idxmap(j1, j2, i1, i2); // this is a unique time1(idx) = ((double)i1 + col1(j1)) / nint1; time2(idx) = ((double)i2 + col2(j2)) / nint2; } } } } sys->p_tau(p_tau, time1, par); p_xx.clear(); for (size_t idx = 0; idx < time1.size(); ++idx) { t1[0] = time1(idx); t2[0] = time2(idx); for (size_t k = 0; k < NTAU; k++) { t1[1+k] = (t1[0] - p_tau(k,idx) / par(0)) - floor(t1[0] - p_tau(k,idx) / par(0)); t2[1+k] = (t2[0] - par(RHO) * p_tau(k,idx) / par(0)) - floor(t2[0] - par(RHO) * p_tau(k,idx) / par(0)); } for (size_t k = 0; k < NTAU + 1; k++) { size_t i1 = static_cast<size_t>(floor(nint1 * t1[k])); size_t i2 = static_cast<size_t>(floor(nint2 * t2[k])); // some error checking if ((t1[k] > 1.0) || (t2[k] > 1.0) || (t1[k] < 0.0) || (t2[k] < 0.0)) std::cout << "Er "; if ((i1 >= nint1) || (i2 >= nint2)) std::cout << "Ei "; // end error checking for (size_t j2 = 0; j2 < ndeg2 + 1; j2++) { for (size_t j1 = 0; j1 < ndeg1 + 1; j1++) { const size_t idxKK = idxkk(j1, j2, k); kk(idxKK,idx) = idxmap(j1, j2, i1, i2); ee(idxKK,idx) = idxKK; } } } // sorting comp aa(kk.pointer(0,idx)); std::sort(ee.pointer(0,idx), ee.pointer(0,idx) + (NTAU + 1)*(ndeg1 + 1)*(ndeg2 + 1), aa); // filtering same indices rr(ee(0,idx),idx) = 0; size_t nz = 0; for (size_t i = 1; i < (NTAU + 1)*(ndeg1 + 1)*(ndeg2 + 1); i++) { if (kk(ee(i-1,idx),idx) != kk(ee(i,idx),idx)) nz++; rr(ee(i,idx),idx) = nz; } // interpolate the solution for (size_t k = 1; k < NTAU + 1; k++) { const double c1 = nint1 * t1[k] - floor(nint1 * t1[k]); const double c2 = nint2 * t2[k] - floor(nint2 * t2[k]); for (size_t j2 = 0; j2 < ndeg2 + 1; j2++) { for (size_t j1 = 0; j1 < ndeg1 + 1; j1++) { const size_t idxKK = idxkk(j1, j2, k); const double cf = poly_lgr_eval(mesh1, j1, c1) * poly_lgr_eval(mesh2, j2, c2); for (size_t p = 0; p < NDIM; p++) { p_xx(p, k - 1, idx) += cf * sol(p + NDIM * kk(idxKK, idx)); } } } } // derivatives at all delays for (size_t k = 0; k < NTAU + 1; k++) { const double c1 = nint1 * t1[k] - floor(nint1 * t1[k]); const double c2 = nint2 * t2[k] - floor(nint2 * t2[k]); for (size_t j2 = 0; j2 < ndeg2 + 1; j2++) { for (size_t j1 = 0; j1 < ndeg1 + 1; j1++) { const size_t idxKK = idxkk(j1, j2, k); const double cf1 = poly_dlg_eval(mesh1, j1, c1) * nint1 * poly_lgr_eval(mesh2, j2, c2); const double cf2 = poly_lgr_eval(mesh1, j1, c1) * poly_dlg_eval(mesh2, j2, c2) * nint2; for (size_t p = 0; p < NDIM; p++) { p_xx(p, NTAU + 2*k, idx) += cf1 * sol(p + NDIM * kk(idxKK, idx)); p_xx(p, NTAU + 2*k + 1, idx) += cf2 * sol(p + NDIM * kk(idxKK, idx)); } } } } } // for (int idx = 0; idx < time1.size(); ++idx) std::cout<<p_xx(0, NTAU, idx)<<"\t"; // std::cout<<"\np_xx(0,...) was\n"; delete[] t2; delete[] t1; }
void GLUI_Translation::draw_2d_arrow( int radius, int filled, int orientation ) { float x1 = .2, x2 = .4, y1 = .54, y2 = .94, y0; float x1a, x1b; vec3 col1( 0.0, 0.0, 0.0 ), col2( .45, .45, .45 ), col3( .7, .7, .7 ), col4( 1.0, 1.0, 1.0 ); vec3 c1, c2, c3, c4, c5, c6; vec3 white(1.0,1.0,1.0), black(0.0,0.0,0.0), gray(.45,.45,.45), bkgd(.7,.7,.7); int c_off; /* color index offset */ if ( glui ) bkgd.set(glui->bkgd_color_f[0], glui->bkgd_color_f[1], glui->bkgd_color_f[2]); /* bkgd[0] = 255.0; bkgd[1] = 0; */ /** The following 8 colors define the shading of an octagon, in clockwise order, starting from the upstroke on the left **/ /** This is for an outside and inside octagons **/ vec3 colors_out[]={white, white, white, gray, black, black, black, gray}; vec3 colors_in[] ={bkgd,white,bkgd,gray,gray,gray,gray,gray}; #define SET_COL_OUT(i) glColor3fv((float*) &colors_out[(i)%8][0]); #define SET_COL_IN(i) glColor3fv((float*) &colors_in[(i)%8][0]); x1 = (float)radius * .2; x2 = x1 * 2; y1 = (float)radius * .54; y2 = y1 + x2; x1a = x1; x1b = x1; glMatrixMode(GL_MODELVIEW); glPushMatrix(); #define DRAW_SEG( xa,ya,xb,yb ) glVertex2f(xa,ya); glVertex2f(xb,yb); glScalef( -1.0, 1.0, 1.0 ); if ( orientation == 2 ) { c_off = 4; } else if ( orientation == 0 ) { c_off = 0; glRotatef( 180.0, 0.0, 0.0, 1.0 ); } else if ( orientation == 1 ) { c_off = 2; glRotatef( 90.0, 0.0, 0.0, 1.0 ); } else if ( orientation == 3 ) { c_off = 6; glRotatef( -90.0, 0.0, 0.0, 1.0 ); } if ( trans_type == GLUI_TRANSLATION_Z ) y0 = 0.0; else if ( trans_type == GLUI_TRANSLATION_XY ) y0 = x1; else y0 = 0.0; if ( trans_type == GLUI_TRANSLATION_Z ) { if ( orientation == 0 ) { y1 += 2.0; y2 += 0.0; x1b -= 2.0; x2 -= 2.0; x1a += 2.0; } else if ( orientation == 2 ) { y1 -= 6.0; x1a += 2.0; x1b += 4.0; x2 += 6.0; } } /*** Fill in inside of arrow ***/ if ( NOT filled ) { /*** Means button is up - control is not clicked ***/ /*glColor3f( .8, .8, .8 ); */ set_to_bkgd_color(); glColor3f( bkgd[0]+.07, bkgd[1]+.07, bkgd[2]+.07 ); } else { /*** Button is down on control ***/ glColor3f( .6, .6, .6 ); c_off += 4; /* Indents the shadows - goes from a raised look to embossed */ } /*** Check if control is enabled or not ***/ if ( NOT enabled ) { set_to_bkgd_color(); /*c_off += 4; -- Indents the shadows - goes from a raised look to embossed */ colors_out[0] = colors_out[1] = colors_out[2] = colors_out[7] = gray; colors_out[3] = colors_out[4] = colors_out[5] = colors_out[6] = white; colors_in[0] = colors_in[1] = colors_in[2] = colors_in[7] = white; colors_in[3] = colors_in[4] = colors_in[5] = colors_in[6] = gray; } glBegin( GL_POLYGON ); glVertex2f( 0.0, 0.0 ); glVertex2f( -x1a, 0.0 ); glVertex2f( -x1a, 0.0 ); glVertex2f( -x1b, y1 ); glVertex2f( x1b, y1); glVertex2f( x1a, 0.0 ); glVertex2f( x1a, 0.0 ); glVertex2f( 0.0, 0.0 ); glEnd(); glBegin( GL_TRIANGLES ); glVertex2f( -x2, y1 ); glVertex2f( 0.0, y2 ); glVertex2f( x2, y1 ); glEnd(); glLineWidth( 1.0 ); /*** Draw arrow outline ***/ glBegin( GL_LINES ); SET_COL_IN(1+c_off); DRAW_SEG( 0.0, y2-1.0, -x2, y1-1.0 ); SET_COL_IN(6+c_off); DRAW_SEG( -x2+2.0, y1+1.0, -x1b+1.0, y1+1.0 ); SET_COL_IN(0+c_off); DRAW_SEG( -x1b+1.0, y1+1.0, -x1a+1.0, y0 ); SET_COL_IN(3+c_off); DRAW_SEG( 0.0, y2-1.0, x2, y1-1.0 ); SET_COL_IN(6+c_off); DRAW_SEG( x2-1.0, y1+1.0, x1b-1.0, y1+1.0 ); SET_COL_IN(4+c_off); DRAW_SEG( x1b-1.0, y1+1.0, x1a-1.0, y0 ); SET_COL_OUT(0+c_off); DRAW_SEG( -x1a, y0, -x1b, y1 ); SET_COL_OUT(6+c_off); DRAW_SEG( -x1b, y1, -x2, y1 ); SET_COL_OUT(1+c_off); DRAW_SEG( -x2, y1, 0.0, y2 ); SET_COL_OUT(3+c_off); DRAW_SEG( 0.0, y2, x2, y1 ); SET_COL_OUT(6+c_off); DRAW_SEG( x2, y1, x1b, y1 ); SET_COL_OUT(4+c_off); DRAW_SEG( x1b, y1, x1a, y0 ); glEnd(); #undef DRAW_SEG glPopMatrix(); }
// -------------- // -----Main----- // -------------- int main (int argc, char** argv) { // -------------------------------------- // -----Parse Command Line Arguments----- // -------------------------------------- double normals_radius= 0.005; if (pcl::console::parse (argc, argv, "-n", normals_radius) >= 0) { std::cout << " Radius: " << normals_radius << "\n"; } double harris_radius = 0.5; if (pcl::console::parse (argc, argv, "--hariss_radius", harris_radius) >= 0) { std::cout << " harris_radius: " << harris_radius << "\n"; } double harris_search_radius = 0.01; if (pcl::console::parse (argc, argv, "--harris_search_radius", harris_search_radius) >= 0) { std::cout << " harris_search_radius: " << harris_search_radius << "\n"; } pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudRGB (new pcl::PointCloud<pcl::PointXYZRGB>); pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>); if (pcl::io::loadPCDFile<pcl::PointXYZRGB> (argv[1], *cloudRGB) == -1) //* load the file { std::cout << "Couldn't read file cloud.pcd "; return (-1); } pcl::copyPointCloud(*cloudRGB, *cloud); pcl::PointCloud<pcl::PointXYZ>::Ptr harris3d (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr iss3d (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr susan (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr harris6d (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr sift (new pcl::PointCloud<pcl::PointXYZ>); NormalCloudPtr normals(new NormalCloud()); pcl::NormalEstimationOMP<PointT, NormalT> est; est.setRadiusSearch(normals_radius); est.setInputCloud(cloud); est.compute(*normals); { pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ()); pcl::PointCloud<pcl::PointXYZI>::Ptr keypoints_temp( new pcl::PointCloud<pcl::PointXYZI>()); HarrisKeypoint* detector = new HarrisKeypoint(HarrisKeypoint::HARRIS); detector->setNonMaxSupression(true); detector->setRadius(harris_radius); detector->setRadiusSearch(harris_search_radius); detector->setMethod(HarrisKeypoint::HARRIS); // detector->setKSearch(); detector->setNumberOfThreads(10); detector->setSearchMethod(tree); // detector->setThreshold(); // detector->use_indices_ = false; detector->setInputCloud(cloud); detector->compute(*keypoints_temp); pcl::PointCloud<pcl::PointXYZ>::Ptr keypoints( new pcl::PointCloud<pcl::PointXYZ>()); pcl::copyPointCloud(*keypoints_temp, *harris3d); } std::cout << " harris3d size :" << harris3d->size() << std::endl;; /* { double iss_salient_radius_; double iss_non_max_radius_; double iss_gamma_21_ (0.975); double iss_gamma_32_ (0.975); double iss_min_neighbors_ (20); int iss_threads_ (10); pcl::PointCloud<pcl::PointXYZ>::Ptr keypoints (new pcl::PointCloud<pcl::PointXYZ> ()); pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ()); // Fill in the model cloud double model_resolution = 0.01; // Compute model_resolution iss_salient_radius_ = 6 * model_resolution; iss_non_max_radius_ = 4 * model_resolution; // // Compute keypoints // pcl::ISSKeypoint3D<pcl::PointXYZ, pcl::PointXYZ> iss_detector; iss_detector.setSearchMethod (tree); iss_detector.setSalientRadius (iss_salient_radius_); iss_detector.setNonMaxRadius (iss_non_max_radius_); iss_detector.setThreshold21 (iss_gamma_21_); iss_detector.setThreshold32 (iss_gamma_32_); iss_detector.setMinNeighbors (iss_min_neighbors_); iss_detector.setNumberOfThreads (iss_threads_); iss_detector.setInputCloud (cloud); iss_detector.compute (*iss3d); } std::cout << " iss3d size :" << iss3d->size() << std::endl; { pcl::search::KdTree<pcl::PointXYZRGB>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGB> ()); pcl::SUSANKeypoint<pcl::PointXYZRGB, pcl::PointXYZRGB>* susan3D = new pcl::SUSANKeypoint<pcl::PointXYZRGB, pcl::PointXYZRGB>; susan3D->setInputCloud(cloudRGB); susan3D->setNonMaxSupression(true); susan3D->setSearchMethod(tree); susan3D->setRadius(harris_radius); susan3D->setRadiusSearch(harris_search_radius); pcl::PointCloud<pcl::PointXYZRGB>::Ptr keypoints (new pcl::PointCloud<pcl::PointXYZRGB> ()); susan3D->compute(*keypoints); pcl::PointCloud<pcl::PointXYZ>::Ptr susan(new pcl::PointCloud<pcl::PointXYZ>()); pcl::copyPointCloud(*keypoints, *susan); } std::cout << " susan size :" << susan->size() << std::endl; { pcl::search::KdTree<pcl::PointXYZRGB>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGB> ()); pcl::PointCloud<pcl::PointXYZI>::Ptr keypoints_temp( new pcl::PointCloud<pcl::PointXYZI>()); HarrisKeypoint6D* detector = new HarrisKeypoint6D(HarrisKeypoint::HARRIS); detector->setNonMaxSupression(true); detector->setRadius(harris_radius); detector->setRadiusSearch(harris_search_radius); // detector->setMethod(HarrisKeypoint::HARRIS); detector->setNumberOfThreads(10); detector->setSearchMethod(tree); // detector->setThreshold(); // detector->use_indices_ = false; detector->setInputCloud(cloudRGB); detector->compute(*keypoints_temp); pcl::copyPointCloud(*keypoints_temp, *harris6d); } std::cout << " harris6d size :" << harris6d->size() << std::endl; /* */ pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> white (cloud, 255, 255, 255); pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> red (harris3d, 255, 0, 0); pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> green (iss3d, 0, 255, 0); pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> blue (susan, 0, 0, 255); pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> col2 (harris6d, 255, 0, 255); pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> col3 (sift, 255, 255, 0); ////// boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer (new pcl::visualization::PCLVisualizer ("3D Viewer")); viewer->setBackgroundColor (0, 0, 0); viewer->addPointCloud<pcl::PointXYZ> (cloud, white, "cloud"); viewer->addPointCloud<pcl::PointXYZ> (harris3d, red, "keypoints2"); viewer->addPointCloud<pcl::PointXYZ> (iss3d, green, "keypoints3"); viewer->addPointCloud<pcl::PointXYZ> (susan, blue, "keypoint4s"); viewer->addPointCloud<pcl::PointXYZ> (harris6d, col2, "keypoin3ts"); viewer->addPointCloud<pcl::PointXYZ> (sift, col3, "keypoint36"); viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 4, "keypoints2"); viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 4, "keypoints3"); viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 4, "keypoint4s"); viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 4, "keypoin3ts"); viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 4, "keypoint36"); // viewer->addPointCloudNormals<pcl::PointXYZ, pcl::Normal> (cloud, normals, 5, 0.05, "normals"); viewer->addCoordinateSystem (1.0, "global"); viewer->initCameraParameters (); // viewer->addSphere (cloud->points[0], normals_radius, "sphere+norm", 0); // viewer->addSphere (cloud->points[0], shot_radius, "sphere+shot", 0); //-------------------- // -----Main loop----- //-------------------- while (!viewer->wasStopped ()) { viewer->spinOnce (100); boost::this_thread::sleep (boost::posix_time::microseconds (100000)); } }