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");
}
}
