bool CTargetDirectionFX::RenderCallback( IEffectUnit* pUnit, CMatrix& matWorld, uint32 uCurTime, RenderObjStyle* pRORS ) { IEffectUnitProp* pProp = pUnit->GetProp(); if(/* !bAlphaBlend ||*/ !pUnit->IsInRenderTime() ) { return false; } CEntityClient* pEntity = CEntityClientManager::GetInst()->GetEntityByID( CEntityClientManager::GetInst()->GetDirectorID()); CFPos Pos = pEntity->GetPixelPos(); CVector2f vec2f(m_Pos.x-Pos.x,m_Pos.y-Pos.y); CDir dir; dir.Set(vec2f); float fRotate = dir.uDir* CMath::pi *2/256; CVector3f vec3f =matWorld.GetAxis(3); matWorld.SetRotateY(fRotate); matWorld._41 = vec3f.x; matWorld._42 = vec3f.y; matWorld._43 = vec3f.z; return true; }
// нужен обработчик на неравенство матриц CMatrix CMatrix::operator * (const CMatrix &arg){ UINT n = getRowCount(), m = arg.getColCount(), p = getColCount(), // = RowCount у второй матрицы p2 = arg.getRowCount(); /* избыточно, ввести обработчик */ if (p == p2) // ширина первой матрицы равна высоте второй? { CMatrix Res(n, m); for (UINT i = 0; i < n; i++) { for (UINT j = 0; j < m; j++) { for (UINT k = 0; k < p; k++) { Res[i][j] += (*this)[i][k] * arg[k][j]; } } } return Res; } // не равна { std::string error, msg, place, reason, arg_reason, object; error = "Error: length_error: "; place = "CMatrix CMatrix::operator * (), size = ("; reason = std::to_string(rowCount) + ", " + std::to_string(colCount); arg_reason = std::to_string(n) + ", " + std::to_string(m); object = std::to_string(UINT(this)); msg = error + place + reason + "), arg.size = (" + arg_reason + "), Object = " + object; throw std::length_error(msg); } //return CMatrix(n, m); // возвращаем нулевую матрицу }
/** * drawLives * Zeichnen der verlorenen Leben. */ void GameWorld::drawLives() { int deaths = 3-gameState->getLives(); if(deaths <= 3 && deaths > 0) { CMatrix * modelview = getModelView(); modelview->Push(); modelview->Rotate(-PI/2,1,0,0); modelview->Translate(-2.0,4.2,0.0); for(int i=0; i < deaths; i++) { ModelContainer::getContainer()->drawModel(modelX); modelview->Translate(0.15,0.0,0.0); } modelview->Pop(); /* glPushMatrix(); glTranslatef(-1.0,2.2,0.0); glRotatef(-90,1,0,0); for(int i=0; i < deaths; i++) { ModelContainer::getContainer()->drawModel(modelX); glTranslatef(0.15,0.0,0.0); } glPopMatrix(); */ } }
void computeCorners(CTensor<float>& aImage, CMatrix<float>& aCorners, float aRho) { aCorners.setSize(aImage.xSize(),aImage.ySize()); int aXSize = aImage.xSize(); int aYSize = aImage.ySize(); int aSize = aXSize*aYSize; // Compute gradient CTensor<float> dx(aXSize,aYSize,aImage.zSize()); CTensor<float> dy(aXSize,aYSize,aImage.zSize()); CDerivative<float> aDerivative(3); NFilter::filter(aImage,dx,aDerivative,1,1); NFilter::filter(aImage,dy,1,aDerivative,1); // Compute second moment matrix CMatrix<float> dxx(aXSize,aYSize,0); CMatrix<float> dyy(aXSize,aYSize,0); CMatrix<float> dxy(aXSize,aYSize,0); int i2 = 0; for (int k = 0; k < aImage.zSize(); k++) for (int i = 0; i < aSize; i++,i2++) { dxx.data()[i] += dx.data()[i2]*dx.data()[i2]; dyy.data()[i] += dy.data()[i2]*dy.data()[i2]; dxy.data()[i] += dx.data()[i2]*dy.data()[i2]; } // Smooth second moment matrix NFilter::recursiveSmoothX(dxx,aRho); NFilter::recursiveSmoothY(dxx,aRho); NFilter::recursiveSmoothX(dyy,aRho); NFilter::recursiveSmoothY(dyy,aRho); NFilter::recursiveSmoothX(dxy,aRho); NFilter::recursiveSmoothY(dxy,aRho); // Compute smallest eigenvalue for (int i = 0; i < aSize; i++) { float a = dxx.data()[i]; float b = dxy.data()[i]; float c = dyy.data()[i]; float temp = 0.5*(a+c); float temp2 = temp*temp+b*b-a*c; if (temp2 < 0.0f) aCorners.data()[i] = 0.0f; else aCorners.data()[i] = temp-sqrt(temp2); } }
CPNLBase * CPersistCondSoftMaxDistribFun::Load(CContextLoad *pContext) { int nNode; bool bFactor; bool isUnitFun; CCondSoftMaxDistribFun *pDF; const CNodeType *const* ppNodeType; LoadForDistribFun(&isUnitFun, &nNode, &ppNodeType, pContext); pContext->GetAttribute(&nNode, "NumberOfNodes"); pContext->GetAttribute(&bFactor, "IsFactor"); CMatrix<CSoftMaxDistribFun*> *mat = static_cast<CMatrix<CSoftMaxDistribFun*>*>( pContext->Get("DistributionMatrix")); pDF = CCondSoftMaxDistribFun::Create(nNode, ppNodeType); CMatrixIterator<CSoftMaxDistribFun*> *it = mat->InitIterator(); intVector index; for(; mat->IsValueHere(it); mat->Next(it)) { mat->Index(it, &index); pDF->SetDistribFun(*mat->Value(it), &index.front()); } delete it; return pDF; }
// // Naive implementation // CMatrix<float> denoise_naive( const CMatrix<float>& img, int window_radius, int patch_radius, float sqr_sigma ) { const float inv_sqr_sigma = 1/sqr_sigma; const int x_size = img.xSize(); const int y_size = img.ySize(); CMatrix<float> result(x_size,y_size); // create a gauss lut for the function patch_distance() float* gauss_lut = new float[2*patch_radius+1]; float* gauss_lut_center = gauss_lut+patch_radius; for( int x = -patch_radius; x <= patch_radius; ++x ) *(gauss_lut_center+x) = std::exp(-0.5*x*x/(patch_radius*patch_radius)); #pragma omp parallel for for( int y = 0; y < y_size; ++y ) for( int x = 0; x < x_size; ++x ) { // window const int x1 = std::max(0,x-window_radius); const int y1 = std::max(0,y-window_radius); const int x2 = std::min(x_size-1,x+window_radius); const int y2 = std::min(y_size-1,y+window_radius); float sum = 0; float new_value = 0; for( int ny = y1; ny <= y2; ++ny ) for( int nx = x1; nx <= x2; ++nx ) { float dsqr = patch_distance(img,x,y,nx,ny,patch_radius,gauss_lut_center); float w = std::exp(-dsqr*inv_sqr_sigma); new_value += w*img(nx,ny); sum += w; } result(x,y) = new_value/sum; } delete[] gauss_lut; return result; }
// *************************************************************************** void CMaterial::decompUserTexMat(uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale) { nlassert(stage < IDRV_MAT_MAXTEXTURES); nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage CMatrix convMat; // exported v are already inverted (todo: optim this...) convMat.setRot(CVector::I, -CVector::J, CVector::K); convMat.setPos(CVector::J); const NLMISC::CMatrix texMat = convMat * _TexUserMat->TexMat[stage] * convMat; /// find the rotation around w NLMISC::CVector i = texMat.getI(); NLMISC::CVector j = texMat.getJ(); uScale = sqrtf(i.x * i.x + j.x * j.x); vScale = sqrtf(i.y * i.y + j.y * j.y); // i.normalize(); // float angle = acosf(i.x / i.norm()); if (i.y < 0) { angle = 2.f * (float) NLMISC::Pi - angle; } wRot = angle; // compute position CMatrix InvSR; InvSR.setRot(texMat.getI(), texMat.getJ(), texMat.getK()); InvSR.invert(); CVector half(0.5f, 0.5f, 0.f); CVector offset = half + InvSR * (texMat.getPos() -half); uTrans = - offset.x; vTrans = - offset.y; }
void rotateCamera(float yaw, float pitch, float roll) { CMatrix matrix; float rotate[4][4]; SVect3d view; matrix.LoadIdentity(); matrix.Rotate(roll*0.0174532925, 0.0, 0.0, 1.0); matrix.Rotate(-pitch*0.0174532925, 1.0, 0.0, 0.0); matrix.Rotate(yaw*0.0174532925, 0.0, 1.0, 0.0); matrix.GetMatrixArray((float *)rotate); view.x = rotate[0][0]*0.0 + rotate[0][1]*0.0 + rotate[0][2]*(-1.0); view.y = rotate[1][0]*0.0 + rotate[1][1]*0.0 + rotate[1][2]*(-1.0); view.z = rotate[2][0]*0.0 + rotate[2][1]*0.0 + rotate[2][2]*(-1.0); camUp.x = rotate[0][0]*0.0 + rotate[0][1]*1.0 + rotate[0][2]*0.0; camUp.y = rotate[1][0]*0.0 + rotate[1][1]*1.0 + rotate[1][2]*0.0; camUp.z = rotate[2][0]*0.0 + rotate[2][1]*1.0 + rotate[2][2]*0.0; camLookAt.x = view.x + pos.x; camLookAt.y = view.y + pos.y; camLookAt.z = view.z + pos.z; }
TEST_FIXTURE(MatrixData, Api) { float afArray[4]; CMatrix TestMatrix; //no init TestMatrix.reset(); CHECK_EQUAL(0, TestMatrix.getNumRows()); CHECK_EQUAL(0, TestMatrix.getNumCols()); CHECK_EQUAL(0, TestMatrix.getNorm()); CMatrix Test2 = TestMatrix * TestMatrix * 2.F; CHECK_EQUAL(0, Test2.getNumRows()); CHECK_EQUAL(0, Test2.getNumCols()); CHECK_EQUAL(CMatrix::kMatrixIllegalFunctionParam, TestMatrix.getRow(2,afArray, m_iNumCols)); for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { m_ppfBuff[i][j] = static_cast<float>(i*j); Matrix.setElement(i,j, static_cast<float>(i*j)); } } CHECK_EQUAL(CMatrix::kMatrixIllegalFunctionParam, Matrix.setElement(m_iNumRows,1, static_cast<float>(m_iNumRows))); }
SPosition CPositioningBasicAlgorithm::CalcPositionInternal(std::map<int /*SensorID*/, double /*Distance*/> Measuremnts, SPosition &Accuracy, int &NumOfIterations) { NumOfIterations++; std::vector<int> ParticipatingSensors = GetListOfSensorsInMeasurements(Measuremnts); if ((int)Measuremnts.size() < m_SensorsLocationMap->GetMinNumberOfParticipatingSensor()) { LogEvent(LE_WARNING, __FUNCTION__ ": Tried to calculate position with only %d Sensors. Minimum defined is %d. NOT CALCULATING!", Measuremnts.size(), m_SensorsLocationMap->GetMinNumberOfParticipatingSensor()); return InvalidPosition; } CMatrix B = BuildMatrixB(ParticipatingSensors); VERIFY_MATRIX(B); CMatrix F = BuildMatrixF(Measuremnts); VERIFY_MATRIX(F); CMatrix Bt = B.GetTransposed(); CMatrix Bsquared = (Bt * B); CMatrix Bsquared_inverted = Bsquared.GetInverted(); CMatrix ErrorMatrix = Bsquared_inverted * Bt * F; double dX = ErrorMatrix[0][0]; double dY = ErrorMatrix[1][0]; UpdateLastLocation(dX, dY); if (IsPositionWellEstimated(dX, dY, NumOfIterations)) { Accuracy.x = dX; Accuracy.y = dY; return m_LastPosition; } else return CalcPositionInternal(Measuremnts, Accuracy, NumOfIterations); /*Note: m_LastPosition has changed in this iteration !!*/ }
// compute the gradients wrt parameters and latent variables. double CLinearMapping::logLikelihoodGradient(CMatrix& g) const { double L=0.0; g.zeros(); CMatrix gtemp(1, getOptNumParams()); for(unsigned int j=0; j<getOutputDim(); j++) { for(unsigned int i=0; i<getNumData(); i++) { double diff = outGradParams(gtemp, *pX, i, j) - py->getVal(i, j); L+= diff*diff; gtemp.scale(-diff/variance); g.add(gtemp); } } L=L/variance; L+=(double)getNumData()*(ndlutil::LOGTWOPI + log(variance)); L*=-0.5; //L+=priorLogProb(); return L; }
void COBB::Untransform(const CVector<3, Num> &vCenter, const CVector<3, Num> (&vExtent)[3], CVector<3, Num> &vMin, CVector<3, Num> &vMax, CXForm &kXForm) { int i; CMatrix<3, 3, Num> mRot; for (i = 0; i < 3; i++) { vMax[i] = vExtent[i].Length(); vMin[i] = -vMax[i]; mRot.SetRow(i, vExtent[i] * (1 / vMax[i])); } kXForm.SetRotation(mRot); kXForm.SetTranslation(vCenter); kXForm.SetScale(CVector<3, Num>::Get(1, 1, 1)); #ifdef _DEBUG CAABB kAABB(vMin, vMax); COBB *pOBB = Cast<COBB>(kAABB.GetTransformed(kXForm)); ASSERT(pOBB); ASSERT(IsEqual((vCenter - pOBB->m_vCenter).Length(), 0)); for (i = 0; i < 3; i++) ASSERT(IsEqual((vExtent[i] - pOBB->m_vExtent[i]).Length(), 0)); #endif }
void CCamera::_UpdateEx(void) const { //------------------------ //更新view matrix和 视锥体 //------------------------ // View matrix is: // [ Rx Ry Rz 0 ] // [ Ux Uy Uz 0 ] // [ Dx Dy Dz 0 ] // [ Tx Ty Tz 1 ] CVector3f vDIRECTIONz = m_matCached.getColumn(2); CVector2f DirYZr(vDIRECTIONz.x, vDIRECTIONz.z); DirYZr.Normalize(); m_matBillboardNoneX.Identity(); m_matBillboardNoneX._11 = DirYZr.y; m_matBillboardNoneX._13 = -DirYZr.x; m_matBillboardNoneX._31 = DirYZr.x; m_matBillboardNoneX._33 = DirYZr.y; CMatrix RotateX; RotateX.SetRotateX(asinf( -vDIRECTIONz.y )); m_matBillboardAll = RotateX*m_matBillboardNoneX; m_matView = m_matCached; m_matView.Transpose3x3(); CVector3f trans = m_v3Position; trans.Rotate( m_matView ); m_matView.m[3][0] = -trans.x; m_matView.m[3][1] = -trans.y; m_matView.m[3][2] = -trans.z; m_matView = m_matDeltaView * m_matView; //View matrix 更新完毕 //下面更新 视锥体 updateFrustum(); m_matViewProject = m_matView * m_matProj; //向量向视锥体里 m_Frustum.Update(m_matViewProject); }
//============================================ bool CWaveMakerShape::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix) { // we just test if not too far const CWaterHeightMap &whm = GetWaterPoolManager().getPoolByID(_PoolID); const float maxDist = 0.5f * whm.getUnitSize() * whm.getSize(); const NLMISC::CVector pos = worldMatrix.getPos(); for (std::vector<NLMISC::CPlane>::const_iterator it = pyramid.begin(); it != pyramid.end(); ++it) { if ((*it) * pos > maxDist) return false; } return true; }
void CDebug::TestDBInsert() { CSigCreate sig; // TestCov(); if(sig.CreateSigStruct()) cout << "true" << endl; else cout << "false" << endl; // 测试地图模块,给数据库插入签名设置一个地图。 CMatrix matmap; matmap.SetMapID(1); matmap.SetRange(3000.0, 3000.0, 8000.0, 10000.0); matmap.SetSize(40, 40); PhoneList* phlist = sig.GetPhoneList(); CFpCreate fp(phlist); //#if 0 // 测试数据库的所有插入操作。 vector<PhoneInfo>::iterator iter1 = phlist->phoneInfoList.begin(); vector<PhoneInfo>::iterator iter2 = phlist->phoneInfoList.end(); for (; iter1 != iter2; iter1++) { int nPhoneID = (*iter1).nPhoneID; Signatrue tmp; fp.GetSig(nPhoneID,&tmp);//只是一个签名 CDBoperate dbope; dbope.SaveSignature(&tmp); dbope.OpenDB("FingerPrintTestSet.db"); dbope.CreateOneFingerPrint(matmap); dbope.CloseDB(); } }
void CEditEllipse::Render() const { size_t PointNum = m_spherePoints.size(); if( PointNum == 0 ) return; VerColor3D* pVB; RenderState* pRS; CMatrix* pMatrix = CGraphic::GetInst()->GetRenderStack( RS_DEFAULT, NULL, NULL, PT_LINESTRIP, PointNum, PointNum/2, VerColor3D::Format, sizeof(VerColor3D), (void**)&pVB, NULL, (void**)&pRS ); pRS->m_LightEnable = FALSE; pMatrix->Identity(); for ( size_t m = 0; m < PointNum; ++m ) { pVB[m].p = m_spherePoints[m]; pVB[m].diffuse = m_dwColor; } pMatrix->Identity(); }
CMatrix CMatrix::transpose() { int iNumOldRows = m_aiMatrixDimensions[kRow], iNumOldCols = m_aiMatrixDimensions[kCol], iNumNewRows = m_aiMatrixDimensions[kCol], iNumNewCols = m_aiMatrixDimensions[kRow]; CMatrix NewMatrix; NewMatrix.init(iNumNewRows, iNumNewCols); float **ppfNew = NewMatrix.getMatrixPtr(); for (int i = 0; i < iNumOldRows; i++) { for (int j = 0; j < iNumOldCols; j++) { //MatrixError_t rErr = NewMatrix.setElement(j, i, this->getElement(i, j)); //assert (rErr == kMatrixNoError); ppfNew[j][i] = m_ppfMatrix[i][j]; } } return NewMatrix; }
// *************************************************************************** void CSkeletonSpawnScript::evaluate(CSkeletonModel *skeleton) { // if same cache, don't need to update parsed instances if(_Cache!=skeleton->getSpawnScript()) { _Cache=skeleton->getSpawnScript(); parseCache(skeleton->getOwnerScene(), skeleton); } // each frame, update PS UserMatrix for(uint i=0;i<_Instances.size();i++) { CInstance &inst= _Instances[i]; if(inst.Model && inst.PS) { CMatrix userMat; userMat.setRot(CVector::I, skeleton->getSSSWODir(), CVector::K); userMat.normalize(CMatrix::YZX); userMat.setPos(skeleton->getSSSWOPos()); inst.PS->setUserMatrix(userMat); } } }
template <class R> CMatrix<R> operator * (const CMatrix<R>& a, const CMatrix<R>& b) { ASSERT(a.getColumnCount() == b.getRowCount()); CMatrix<R> result = CMatrix<R>(b.getColumnCount()); for (int q = 0; q < a.getRowCount(); q++) { CVector<R> row = CVector<R>(); for (int r = 0; r < b.getColumnCount(); r++) { R sum = 0; for (int k = 0; k < a.getColumnCount(); k++) sum += a[q][k] * b[k][r]; row.appendElement(sum); } result.addRow(row); } return result; }
//*************************************************************************************************************** bool CFlareShape::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix) { // compute flare pos in world basis : const NLMISC::CVector pos = worldMatrix.getPos(); for (std::vector<NLMISC::CPlane>::const_iterator it = pyramid.begin(); it != pyramid.end(); ++it) { if ((*it) * pos > _Size[0]) { //nlwarning("clipped"); return false; } } return true; }
/** * drawTime * Zeichnen der Zeit. */ void GameWorld::drawTime() { int time = getGameState()->getTime(); if(time >= 0) { CMatrix * modelview = getModelView(); modelview->Push(); modelview->Translate(-2.0,4.2,0.0); drawNumber(time); modelview->Pop(); /* glPushMatrix(); glTranslatef(-1.0,2.2,0.0); drawNumber(time); glPopMatrix(); */ } }
CMatrix CMatrix::operator*(CMatrix &other) const { assert(m_aiMatrixDimensions[kCol] == other.getNumRows()); CMatrix ResultMatrix; if (m_aiMatrixDimensions[kCol] == other.getNumRows()) //{ // int iNumResCols = other.getNumCols (); // float** ppfOther = other.getMatrixPtr(); // ResultMatrix.init(m_aiMatrixDimensions[kRow], iNumResCols); // float** ppfResult = ResultMatrix.getMatrixPtr(); // for (int i = 0; i < m_aiMatrixDimensions[kRow]; i++) // { // for (int j = 0; j < iNumResCols; j++) // { // float fResult = 0; // for (int k = 0; k < m_aiMatrixDimensions[kCol]; k++) // fResult += m_ppfMatrix[i][k] * ppfOther[k][j]; // ppfResult[i][j] = fResult; // } // } //} { int iNumResCols = other.getNumCols (); //float** ppfOther = other.getMatrixPtr(); ResultMatrix.init(m_aiMatrixDimensions[kRow], iNumResCols); float** ppfResult = ResultMatrix.getMatrixPtr(); CMatrix TmpMatrix = other.transpose(); for (int i = 0; i < m_aiMatrixDimensions[kRow]; i++) { for (int j = 0; j < iNumResCols; j++) { ppfResult[i][j] = CUtil::mulBuffScalar(m_ppfMatrix[i], TmpMatrix.getRowPtr(j), m_aiMatrixDimensions[kCol]); } } } return ResultMatrix; }
// *********************************************************************************** void CWaterEnvMapRenderFromUScene::doRender(const CMatrix &camMatrix, TGlobalAnimationTime time, UDriver &drv) { if (!_Scene) return; preRender(time, drv); UCamera oldCam = _Scene->getCam(); if (_Cam.empty()) return; _Scene->setCam(_Cam); _Cam.setTransformMode(UTransformable::DirectMatrix); nlassert(!_Cam.empty()); _Cam.setFrustum(-_ZNear, _ZNear, -_ZNear, _ZNear, _ZNear, _ZFar); drv.setCullMode(drv.getCullMode() == UDriver::CCW ? UDriver::CW : UDriver::CCW); CMatrix mat = camMatrix; mat.setPos(_CamPos); _Cam.setMatrix(mat); CViewport old = _Scene->getViewport(); _Scene->setViewport(CViewport()); _Scene->beginPartRender(); _Scene->renderPart(_RenderPart); _Scene->endPartRender(); _Scene->setViewport(old); drv.setCullMode(drv.getCullMode() == UDriver::CCW ? UDriver::CW : UDriver::CCW); _Scene->setCam(oldCam); postRender(time, drv); }
// ********************************************************* void CPrimRender::updateEdgeDecal(CDecal &edgeDecal, const NLMISC::CVector &start, const NLMISC::CVector &end, float distToStartVertex, float distToEndVertex) { //H_AUTO(R2_CPrimRender_updateEdgeDecal) CVector2f start2f(start.x, start.y); CVector2f end2f(end.x, end.y); // compute real start coordinate that is at 'startRadius' dist from the 'start' pos float length = (end2f - start2f).norm(); if ((distToStartVertex + distToEndVertex) >= length) { CMatrix nullMat; nullMat.setScale(0.f); // decal not visible edgeDecal.setWorldMatrix(nullMat); return; } CVector dirNormed = (end2f - start2f) / length; start2f = start2f + distToStartVertex * dirNormed; end2f = end2f - distToEndVertex * dirNormed; edgeDecal.setWorldMatrixForArrow(start2f, end2f, _Look.EdgeLook.DecalWidth); CMatrix uvMatrix; float uScale = _Look.EdgeLook.DecalUScale * (length - (distToStartVertex + distToEndVertex)); uvMatrix.setScale(CVector(uScale, 1.f, 1.f)); switch(_Look.EdgeLook.DecalWrapMode) { case CEdgeLook::Scaled: case CEdgeLook::Repeat: break; case CEdgeLook::Centered: uvMatrix.setPos(CVector(0.5f * (1.f - uScale), 0.f, 0.f)); break; default: nlassert(0); break; } edgeDecal.setTextureMatrix(uvMatrix); }
void CCamera::RotateView(float angle, float x, float y, float z) { CQuaternion NewRot; NewRot.CreateFromDegrees(angle,x,y,z); NewRot.Normalize(); QuatRot.Normalize(); NewRot.Multi(QuatRot); //NewRot now equals or new total rotation QuatRot = NewRot; //renormalize our quaternion QuatRot.Normalize(); CMatrix QuatMatrix; QuatMatrix.SetQuatRotation(QuatRot.GetData()); QuatMatrix.TransformVertex(&View); //keep our Side and Up aligned with our new View vector. View.Normalize(); Side = Up ^ View; Side.Normalize(); }
int main() { CMatrix<float> imageL; imageL.readFromPGM("tsukubaL.pgm"); CMatrix<float> imageR; imageR.readFromPGM("tsukubaR.pgm"); CMatrix<float> result(imageL.xSize(),imageL.ySize()); vector<vector<float> > MesDir1, MesDir2, UnaryCosts; CVector<float> CpixelsL, CpixelsR; vector<float> pixelsL, pixelsR; vector<int> temp_res; for (int y=0; y<imageL.ySize(); ++y) { cout<<"row = "<< y << endl; for (int x=0; x<imageL.xSize(); ++x) { pixelsL.push_back(imageL(x,y)); pixelsR.push_back(imageR(x,y)); } int maxDisparity=15; int direction=1; MesDir1=CreateMessageArray(pixelsL,pixelsR,maxDisparity,direction); direction=-1; MesDir2=CreateMessageArray(pixelsL,pixelsR,maxDisparity,direction); UnaryCosts=CreateUnaryCosts(pixelsL,pixelsR,maxDisparity); temp_res=DecideLabels(MesDir1,MesDir2,UnaryCosts); vectOut(temp_res); for (int x=0; x<imageL.xSize(); ++x) { result(x,y)=temp_res[x]; } pixelsL.clear(); pixelsR.clear(); } result.normalize(0,255,0,15); result.writeToPGM("result.pgm"); return 0; }
void CLinearMapping::out(CMatrix& yPred, const CMatrix& Xin) const { DIMENSIONMATCH(yPred.getRows()==Xin.getRows()); DIMENSIONMATCH(Xin.getCols()==getInputDim()); for(unsigned int i=0; i<yPred.getRows(); i++) { yPred.copyRowRow(i, b, 0); yPred.gemvRowRow(i, W, Xin, i, 1.0, 1.0, "t"); } }
void CMatrix::CopySubMatrix(CMatrix& cMatrix,int nStartX,int nStartY) { if((m_nRow < cMatrix.m_nRow + nStartX ) | (m_nCol < cMatrix.m_nCol + nStartY)) { throw string("被拷贝的矩阵维数小于要拷贝的矩阵所需要的维数!"); return; } for(int i=0; i < cMatrix.m_nRow; i++) { for(int j=0; j < cMatrix.m_nCol; j++) { cMatrix.m_pTMatrix (i, j) = m_pTMatrix (nStartX + i, nStartY + j); } } }
void CMatrix::CopySubMatrixFromVector(CMatrix& cMatrix,int nIndex) { if(m_nCol != 1) { throw string("被拷贝的矩阵不是列向量!!!"); return; } for(int j=0; j < cMatrix.m_nCol; j++) { for(int i=0; i < cMatrix.m_nRow; i++) { cMatrix.m_pTMatrix (i, j) = m_pTMatrix (nIndex + j * cMatrix.m_nRow + i , (int)0); } } }
void CMlpMapping::out(CMatrix& yPred, const CMatrix& Xin) const { DIMENSIONMATCH(yPred.getRows()==Xin.getRows()); DIMENSIONMATCH(Xin.getCols()==getInputDim()); for(unsigned int i=0; i<yPred.getRows(); i++) { hiddenActive.deepCopy(b1); hiddenActive.gemvRowRow(0, W1, Xin, i, 1.0, 1.0, "t"); hiddenActive.tanh(); yPred.copyRowRow(i, b2, 0); yPred.gemvRowRow(i, W2, hiddenActive, 0, 1.0, 1.0, "t"); } }